#ifndef __vulkan_h_
#define __vulkan_h_ 1

#ifdef __cplusplus
extern "C" {
#endif

	/*
	** Copyright (c) 2015-2016 The Khronos Group Inc.
	**
	** Permission is hereby granted, free of charge, to any person obtaining a
	** copy of this software and/or associated documentation files (the
	** "Materials"), to deal in the Materials without restriction, including
	** without limitation the rights to use, copy, modify, merge, publish,
	** distribute, sublicense, and/or sell copies of the Materials, and to
	** permit persons to whom the Materials are furnished to do so, subject to
	** the following conditions:
	**
	** The above copyright notice and this permission notice shall be included
	** in all copies or substantial portions of the Materials.
	**
	** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
	** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
	** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
	** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
	** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
	*/

	/*
	** This header is generated from the Khronos Vulkan XML API Registry.
	**
	*/


#define VK_VERSION_1_0 1
#include "vk_platform.h"

#define VK_MAKE_VERSION(major, minor, patch) \
    (((major) << 22) | ((minor) << 12) | (patch))

	// Vulkan API version supported by this file
#define VK_API_VERSION VK_MAKE_VERSION(1, 0, 3)

#define VK_VERSION_MAJOR(version) ((uint32_t)(version) >> 22)
#define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff)
#define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff)

#define VK_NULL_HANDLE 0



#define VK_DEFINE_HANDLE(object) typedef struct object##_T* object;


#if defined(__LP64__) || defined(_WIN64) || defined(__x86_64__) || defined(_M_X64) || defined(__ia64) || defined (_M_IA64) || defined(__aarch64__) || defined(__powerpc64__)
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;
#else
#define VK_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef uint64_t object;
#endif



	typedef uint32_t VkFlags;
	typedef uint32_t VkBool32;
	typedef uint64_t VkDeviceSize;
	typedef uint32_t VkSampleMask;

	VK_DEFINE_HANDLE(VkInstance)
		VK_DEFINE_HANDLE(VkPhysicalDevice)
		VK_DEFINE_HANDLE(VkDevice)
		VK_DEFINE_HANDLE(VkQueue)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSemaphore)
		VK_DEFINE_HANDLE(VkCommandBuffer)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFence)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDeviceMemory)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBuffer)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImage)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkEvent)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkQueryPool)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkBufferView)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkImageView)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkShaderModule)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineCache)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipelineLayout)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkRenderPass)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkPipeline)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSetLayout)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSampler)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorPool)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDescriptorSet)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkFramebuffer)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkCommandPool)

#define VK_LOD_CLAMP_NONE                 1000.0f
#define VK_REMAINING_MIP_LEVELS           (~0U)
#define VK_REMAINING_ARRAY_LAYERS         (~0U)
#define VK_WHOLE_SIZE                     (~0ULL)
#define VK_ATTACHMENT_UNUSED              (~0U)
#define VK_TRUE                           1
#define VK_FALSE                          0
#define VK_QUEUE_FAMILY_IGNORED           (~0U)
#define VK_SUBPASS_EXTERNAL               (~0U)
#define VK_MAX_PHYSICAL_DEVICE_NAME_SIZE  256
#define VK_UUID_SIZE                      16
#define VK_MAX_MEMORY_TYPES               32
#define VK_MAX_MEMORY_HEAPS               16
#define VK_MAX_EXTENSION_NAME_SIZE        256
#define VK_MAX_DESCRIPTION_SIZE           256


		typedef enum VkPipelineCacheHeaderVersion {
		VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
		VK_PIPELINE_CACHE_HEADER_VERSION_BEGIN_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
		VK_PIPELINE_CACHE_HEADER_VERSION_END_RANGE = VK_PIPELINE_CACHE_HEADER_VERSION_ONE,
		VK_PIPELINE_CACHE_HEADER_VERSION_RANGE_SIZE = (VK_PIPELINE_CACHE_HEADER_VERSION_ONE - VK_PIPELINE_CACHE_HEADER_VERSION_ONE + 1),
		VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
	} VkPipelineCacheHeaderVersion;

	typedef enum VkResult {
		VK_SUCCESS = 0,
		VK_NOT_READY = 1,
		VK_TIMEOUT = 2,
		VK_EVENT_SET = 3,
		VK_EVENT_RESET = 4,
		VK_INCOMPLETE = 5,
		VK_ERROR_OUT_OF_HOST_MEMORY = -1,
		VK_ERROR_OUT_OF_DEVICE_MEMORY = -2,
		VK_ERROR_INITIALIZATION_FAILED = -3,
		VK_ERROR_DEVICE_LOST = -4,
		VK_ERROR_MEMORY_MAP_FAILED = -5,
		VK_ERROR_LAYER_NOT_PRESENT = -6,
		VK_ERROR_EXTENSION_NOT_PRESENT = -7,
		VK_ERROR_FEATURE_NOT_PRESENT = -8,
		VK_ERROR_INCOMPATIBLE_DRIVER = -9,
		VK_ERROR_TOO_MANY_OBJECTS = -10,
		VK_ERROR_FORMAT_NOT_SUPPORTED = -11,
		VK_ERROR_SURFACE_LOST_KHR = -1000000000,
		VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001,
		VK_SUBOPTIMAL_KHR = 1000001003,
		VK_ERROR_OUT_OF_DATE_KHR = -1000001004,
		VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001,
		VK_ERROR_VALIDATION_FAILED_EXT = -1000011001,
		VK_RESULT_BEGIN_RANGE = VK_ERROR_FORMAT_NOT_SUPPORTED,
		VK_RESULT_END_RANGE = VK_INCOMPLETE,
		VK_RESULT_RANGE_SIZE = (VK_INCOMPLETE - VK_ERROR_FORMAT_NOT_SUPPORTED + 1),
		VK_RESULT_MAX_ENUM = 0x7FFFFFFF
	} VkResult;

	typedef enum VkStructureType {
		VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
		VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
		VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2,
		VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3,
		VK_STRUCTURE_TYPE_SUBMIT_INFO = 4,
		VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5,
		VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6,
		VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7,
		VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8,
		VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9,
		VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10,
		VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11,
		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12,
		VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13,
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14,
		VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15,
		VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16,
		VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17,
		VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18,
		VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19,
		VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20,
		VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21,
		VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22,
		VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23,
		VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24,
		VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25,
		VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26,
		VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27,
		VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28,
		VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29,
		VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30,
		VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31,
		VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32,
		VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33,
		VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34,
		VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35,
		VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36,
		VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37,
		VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38,
		VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39,
		VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40,
		VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41,
		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42,
		VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43,
		VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44,
		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45,
		VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46,
		VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47,
		VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
		VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000,
		VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001,
		VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000,
		VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001,
		VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000,
		VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000,
		VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000,
		VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000,
		VK_STRUCTURE_TYPE_MIR_SURFACE_CREATE_INFO_KHR = 1000007000,
		VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000,
		VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000,
		VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = 1000011000,
		VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO,
		VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
		VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1),
		VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkStructureType;

	typedef enum VkSystemAllocationScope {
		VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
		VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
		VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2,
		VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3,
		VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
		VK_SYSTEM_ALLOCATION_SCOPE_BEGIN_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_COMMAND,
		VK_SYSTEM_ALLOCATION_SCOPE_END_RANGE = VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE,
		VK_SYSTEM_ALLOCATION_SCOPE_RANGE_SIZE = (VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND + 1),
		VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
	} VkSystemAllocationScope;

	typedef enum VkInternalAllocationType {
		VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
		VK_INTERNAL_ALLOCATION_TYPE_BEGIN_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
		VK_INTERNAL_ALLOCATION_TYPE_END_RANGE = VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE,
		VK_INTERNAL_ALLOCATION_TYPE_RANGE_SIZE = (VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE + 1),
		VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkInternalAllocationType;

	typedef enum VkFormat {
		VK_FORMAT_UNDEFINED = 0,
		VK_FORMAT_R4G4_UNORM_PACK8 = 1,
		VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2,
		VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3,
		VK_FORMAT_R5G6B5_UNORM_PACK16 = 4,
		VK_FORMAT_B5G6R5_UNORM_PACK16 = 5,
		VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6,
		VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7,
		VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8,
		VK_FORMAT_R8_UNORM = 9,
		VK_FORMAT_R8_SNORM = 10,
		VK_FORMAT_R8_USCALED = 11,
		VK_FORMAT_R8_SSCALED = 12,
		VK_FORMAT_R8_UINT = 13,
		VK_FORMAT_R8_SINT = 14,
		VK_FORMAT_R8_SRGB = 15,
		VK_FORMAT_R8G8_UNORM = 16,
		VK_FORMAT_R8G8_SNORM = 17,
		VK_FORMAT_R8G8_USCALED = 18,
		VK_FORMAT_R8G8_SSCALED = 19,
		VK_FORMAT_R8G8_UINT = 20,
		VK_FORMAT_R8G8_SINT = 21,
		VK_FORMAT_R8G8_SRGB = 22,
		VK_FORMAT_R8G8B8_UNORM = 23,
		VK_FORMAT_R8G8B8_SNORM = 24,
		VK_FORMAT_R8G8B8_USCALED = 25,
		VK_FORMAT_R8G8B8_SSCALED = 26,
		VK_FORMAT_R8G8B8_UINT = 27,
		VK_FORMAT_R8G8B8_SINT = 28,
		VK_FORMAT_R8G8B8_SRGB = 29,
		VK_FORMAT_B8G8R8_UNORM = 30,
		VK_FORMAT_B8G8R8_SNORM = 31,
		VK_FORMAT_B8G8R8_USCALED = 32,
		VK_FORMAT_B8G8R8_SSCALED = 33,
		VK_FORMAT_B8G8R8_UINT = 34,
		VK_FORMAT_B8G8R8_SINT = 35,
		VK_FORMAT_B8G8R8_SRGB = 36,
		VK_FORMAT_R8G8B8A8_UNORM = 37,
		VK_FORMAT_R8G8B8A8_SNORM = 38,
		VK_FORMAT_R8G8B8A8_USCALED = 39,
		VK_FORMAT_R8G8B8A8_SSCALED = 40,
		VK_FORMAT_R8G8B8A8_UINT = 41,
		VK_FORMAT_R8G8B8A8_SINT = 42,
		VK_FORMAT_R8G8B8A8_SRGB = 43,
		VK_FORMAT_B8G8R8A8_UNORM = 44,
		VK_FORMAT_B8G8R8A8_SNORM = 45,
		VK_FORMAT_B8G8R8A8_USCALED = 46,
		VK_FORMAT_B8G8R8A8_SSCALED = 47,
		VK_FORMAT_B8G8R8A8_UINT = 48,
		VK_FORMAT_B8G8R8A8_SINT = 49,
		VK_FORMAT_B8G8R8A8_SRGB = 50,
		VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51,
		VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52,
		VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53,
		VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54,
		VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55,
		VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56,
		VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57,
		VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58,
		VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59,
		VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60,
		VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61,
		VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62,
		VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63,
		VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64,
		VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65,
		VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66,
		VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67,
		VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68,
		VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69,
		VK_FORMAT_R16_UNORM = 70,
		VK_FORMAT_R16_SNORM = 71,
		VK_FORMAT_R16_USCALED = 72,
		VK_FORMAT_R16_SSCALED = 73,
		VK_FORMAT_R16_UINT = 74,
		VK_FORMAT_R16_SINT = 75,
		VK_FORMAT_R16_SFLOAT = 76,
		VK_FORMAT_R16G16_UNORM = 77,
		VK_FORMAT_R16G16_SNORM = 78,
		VK_FORMAT_R16G16_USCALED = 79,
		VK_FORMAT_R16G16_SSCALED = 80,
		VK_FORMAT_R16G16_UINT = 81,
		VK_FORMAT_R16G16_SINT = 82,
		VK_FORMAT_R16G16_SFLOAT = 83,
		VK_FORMAT_R16G16B16_UNORM = 84,
		VK_FORMAT_R16G16B16_SNORM = 85,
		VK_FORMAT_R16G16B16_USCALED = 86,
		VK_FORMAT_R16G16B16_SSCALED = 87,
		VK_FORMAT_R16G16B16_UINT = 88,
		VK_FORMAT_R16G16B16_SINT = 89,
		VK_FORMAT_R16G16B16_SFLOAT = 90,
		VK_FORMAT_R16G16B16A16_UNORM = 91,
		VK_FORMAT_R16G16B16A16_SNORM = 92,
		VK_FORMAT_R16G16B16A16_USCALED = 93,
		VK_FORMAT_R16G16B16A16_SSCALED = 94,
		VK_FORMAT_R16G16B16A16_UINT = 95,
		VK_FORMAT_R16G16B16A16_SINT = 96,
		VK_FORMAT_R16G16B16A16_SFLOAT = 97,
		VK_FORMAT_R32_UINT = 98,
		VK_FORMAT_R32_SINT = 99,
		VK_FORMAT_R32_SFLOAT = 100,
		VK_FORMAT_R32G32_UINT = 101,
		VK_FORMAT_R32G32_SINT = 102,
		VK_FORMAT_R32G32_SFLOAT = 103,
		VK_FORMAT_R32G32B32_UINT = 104,
		VK_FORMAT_R32G32B32_SINT = 105,
		VK_FORMAT_R32G32B32_SFLOAT = 106,
		VK_FORMAT_R32G32B32A32_UINT = 107,
		VK_FORMAT_R32G32B32A32_SINT = 108,
		VK_FORMAT_R32G32B32A32_SFLOAT = 109,
		VK_FORMAT_R64_UINT = 110,
		VK_FORMAT_R64_SINT = 111,
		VK_FORMAT_R64_SFLOAT = 112,
		VK_FORMAT_R64G64_UINT = 113,
		VK_FORMAT_R64G64_SINT = 114,
		VK_FORMAT_R64G64_SFLOAT = 115,
		VK_FORMAT_R64G64B64_UINT = 116,
		VK_FORMAT_R64G64B64_SINT = 117,
		VK_FORMAT_R64G64B64_SFLOAT = 118,
		VK_FORMAT_R64G64B64A64_UINT = 119,
		VK_FORMAT_R64G64B64A64_SINT = 120,
		VK_FORMAT_R64G64B64A64_SFLOAT = 121,
		VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122,
		VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123,
		VK_FORMAT_D16_UNORM = 124,
		VK_FORMAT_X8_D24_UNORM_PACK32 = 125,
		VK_FORMAT_D32_SFLOAT = 126,
		VK_FORMAT_S8_UINT = 127,
		VK_FORMAT_D16_UNORM_S8_UINT = 128,
		VK_FORMAT_D24_UNORM_S8_UINT = 129,
		VK_FORMAT_D32_SFLOAT_S8_UINT = 130,
		VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131,
		VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132,
		VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133,
		VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134,
		VK_FORMAT_BC2_UNORM_BLOCK = 135,
		VK_FORMAT_BC2_SRGB_BLOCK = 136,
		VK_FORMAT_BC3_UNORM_BLOCK = 137,
		VK_FORMAT_BC3_SRGB_BLOCK = 138,
		VK_FORMAT_BC4_UNORM_BLOCK = 139,
		VK_FORMAT_BC4_SNORM_BLOCK = 140,
		VK_FORMAT_BC5_UNORM_BLOCK = 141,
		VK_FORMAT_BC5_SNORM_BLOCK = 142,
		VK_FORMAT_BC6H_UFLOAT_BLOCK = 143,
		VK_FORMAT_BC6H_SFLOAT_BLOCK = 144,
		VK_FORMAT_BC7_UNORM_BLOCK = 145,
		VK_FORMAT_BC7_SRGB_BLOCK = 146,
		VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147,
		VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148,
		VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149,
		VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150,
		VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151,
		VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152,
		VK_FORMAT_EAC_R11_UNORM_BLOCK = 153,
		VK_FORMAT_EAC_R11_SNORM_BLOCK = 154,
		VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155,
		VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156,
		VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157,
		VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158,
		VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159,
		VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160,
		VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161,
		VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162,
		VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163,
		VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164,
		VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165,
		VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166,
		VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167,
		VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168,
		VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169,
		VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170,
		VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171,
		VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172,
		VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173,
		VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174,
		VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175,
		VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176,
		VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177,
		VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178,
		VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179,
		VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180,
		VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181,
		VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182,
		VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183,
		VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184,
		VK_FORMAT_BEGIN_RANGE = VK_FORMAT_UNDEFINED,
		VK_FORMAT_END_RANGE = VK_FORMAT_ASTC_12x12_SRGB_BLOCK,
		VK_FORMAT_RANGE_SIZE = (VK_FORMAT_ASTC_12x12_SRGB_BLOCK - VK_FORMAT_UNDEFINED + 1),
		VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
	} VkFormat;

	typedef enum VkImageType {
		VK_IMAGE_TYPE_1D = 0,
		VK_IMAGE_TYPE_2D = 1,
		VK_IMAGE_TYPE_3D = 2,
		VK_IMAGE_TYPE_BEGIN_RANGE = VK_IMAGE_TYPE_1D,
		VK_IMAGE_TYPE_END_RANGE = VK_IMAGE_TYPE_3D,
		VK_IMAGE_TYPE_RANGE_SIZE = (VK_IMAGE_TYPE_3D - VK_IMAGE_TYPE_1D + 1),
		VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkImageType;

	typedef enum VkImageTiling {
		VK_IMAGE_TILING_OPTIMAL = 0,
		VK_IMAGE_TILING_LINEAR = 1,
		VK_IMAGE_TILING_BEGIN_RANGE = VK_IMAGE_TILING_OPTIMAL,
		VK_IMAGE_TILING_END_RANGE = VK_IMAGE_TILING_LINEAR,
		VK_IMAGE_TILING_RANGE_SIZE = (VK_IMAGE_TILING_LINEAR - VK_IMAGE_TILING_OPTIMAL + 1),
		VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
	} VkImageTiling;

	typedef enum VkPhysicalDeviceType {
		VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
		VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
		VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2,
		VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3,
		VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
		VK_PHYSICAL_DEVICE_TYPE_BEGIN_RANGE = VK_PHYSICAL_DEVICE_TYPE_OTHER,
		VK_PHYSICAL_DEVICE_TYPE_END_RANGE = VK_PHYSICAL_DEVICE_TYPE_CPU,
		VK_PHYSICAL_DEVICE_TYPE_RANGE_SIZE = (VK_PHYSICAL_DEVICE_TYPE_CPU - VK_PHYSICAL_DEVICE_TYPE_OTHER + 1),
		VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkPhysicalDeviceType;

	typedef enum VkQueryType {
		VK_QUERY_TYPE_OCCLUSION = 0,
		VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
		VK_QUERY_TYPE_TIMESTAMP = 2,
		VK_QUERY_TYPE_BEGIN_RANGE = VK_QUERY_TYPE_OCCLUSION,
		VK_QUERY_TYPE_END_RANGE = VK_QUERY_TYPE_TIMESTAMP,
		VK_QUERY_TYPE_RANGE_SIZE = (VK_QUERY_TYPE_TIMESTAMP - VK_QUERY_TYPE_OCCLUSION + 1),
		VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkQueryType;

	typedef enum VkSharingMode {
		VK_SHARING_MODE_EXCLUSIVE = 0,
		VK_SHARING_MODE_CONCURRENT = 1,
		VK_SHARING_MODE_BEGIN_RANGE = VK_SHARING_MODE_EXCLUSIVE,
		VK_SHARING_MODE_END_RANGE = VK_SHARING_MODE_CONCURRENT,
		VK_SHARING_MODE_RANGE_SIZE = (VK_SHARING_MODE_CONCURRENT - VK_SHARING_MODE_EXCLUSIVE + 1),
		VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
	} VkSharingMode;

	typedef enum VkImageLayout {
		VK_IMAGE_LAYOUT_UNDEFINED = 0,
		VK_IMAGE_LAYOUT_GENERAL = 1,
		VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2,
		VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3,
		VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4,
		VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5,
		VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6,
		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7,
		VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
		VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002,
		VK_IMAGE_LAYOUT_BEGIN_RANGE = VK_IMAGE_LAYOUT_UNDEFINED,
		VK_IMAGE_LAYOUT_END_RANGE = VK_IMAGE_LAYOUT_PREINITIALIZED,
		VK_IMAGE_LAYOUT_RANGE_SIZE = (VK_IMAGE_LAYOUT_PREINITIALIZED - VK_IMAGE_LAYOUT_UNDEFINED + 1),
		VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
	} VkImageLayout;

	typedef enum VkImageViewType {
		VK_IMAGE_VIEW_TYPE_1D = 0,
		VK_IMAGE_VIEW_TYPE_2D = 1,
		VK_IMAGE_VIEW_TYPE_3D = 2,
		VK_IMAGE_VIEW_TYPE_CUBE = 3,
		VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4,
		VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5,
		VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
		VK_IMAGE_VIEW_TYPE_BEGIN_RANGE = VK_IMAGE_VIEW_TYPE_1D,
		VK_IMAGE_VIEW_TYPE_END_RANGE = VK_IMAGE_VIEW_TYPE_CUBE_ARRAY,
		VK_IMAGE_VIEW_TYPE_RANGE_SIZE = (VK_IMAGE_VIEW_TYPE_CUBE_ARRAY - VK_IMAGE_VIEW_TYPE_1D + 1),
		VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkImageViewType;

	typedef enum VkComponentSwizzle {
		VK_COMPONENT_SWIZZLE_IDENTITY = 0,
		VK_COMPONENT_SWIZZLE_ZERO = 1,
		VK_COMPONENT_SWIZZLE_ONE = 2,
		VK_COMPONENT_SWIZZLE_R = 3,
		VK_COMPONENT_SWIZZLE_G = 4,
		VK_COMPONENT_SWIZZLE_B = 5,
		VK_COMPONENT_SWIZZLE_A = 6,
		VK_COMPONENT_SWIZZLE_BEGIN_RANGE = VK_COMPONENT_SWIZZLE_IDENTITY,
		VK_COMPONENT_SWIZZLE_END_RANGE = VK_COMPONENT_SWIZZLE_A,
		VK_COMPONENT_SWIZZLE_RANGE_SIZE = (VK_COMPONENT_SWIZZLE_A - VK_COMPONENT_SWIZZLE_IDENTITY + 1),
		VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
	} VkComponentSwizzle;

	typedef enum VkVertexInputRate {
		VK_VERTEX_INPUT_RATE_VERTEX = 0,
		VK_VERTEX_INPUT_RATE_INSTANCE = 1,
		VK_VERTEX_INPUT_RATE_BEGIN_RANGE = VK_VERTEX_INPUT_RATE_VERTEX,
		VK_VERTEX_INPUT_RATE_END_RANGE = VK_VERTEX_INPUT_RATE_INSTANCE,
		VK_VERTEX_INPUT_RATE_RANGE_SIZE = (VK_VERTEX_INPUT_RATE_INSTANCE - VK_VERTEX_INPUT_RATE_VERTEX + 1),
		VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
	} VkVertexInputRate;

	typedef enum VkPrimitiveTopology {
		VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
		VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
		VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2,
		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3,
		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4,
		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5,
		VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6,
		VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7,
		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8,
		VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9,
		VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
		VK_PRIMITIVE_TOPOLOGY_BEGIN_RANGE = VK_PRIMITIVE_TOPOLOGY_POINT_LIST,
		VK_PRIMITIVE_TOPOLOGY_END_RANGE = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST,
		VK_PRIMITIVE_TOPOLOGY_RANGE_SIZE = (VK_PRIMITIVE_TOPOLOGY_PATCH_LIST - VK_PRIMITIVE_TOPOLOGY_POINT_LIST + 1),
		VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
	} VkPrimitiveTopology;

	typedef enum VkPolygonMode {
		VK_POLYGON_MODE_FILL = 0,
		VK_POLYGON_MODE_LINE = 1,
		VK_POLYGON_MODE_POINT = 2,
		VK_POLYGON_MODE_BEGIN_RANGE = VK_POLYGON_MODE_FILL,
		VK_POLYGON_MODE_END_RANGE = VK_POLYGON_MODE_POINT,
		VK_POLYGON_MODE_RANGE_SIZE = (VK_POLYGON_MODE_POINT - VK_POLYGON_MODE_FILL + 1),
		VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
	} VkPolygonMode;

	typedef enum VkFrontFace {
		VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
		VK_FRONT_FACE_CLOCKWISE = 1,
		VK_FRONT_FACE_BEGIN_RANGE = VK_FRONT_FACE_COUNTER_CLOCKWISE,
		VK_FRONT_FACE_END_RANGE = VK_FRONT_FACE_CLOCKWISE,
		VK_FRONT_FACE_RANGE_SIZE = (VK_FRONT_FACE_CLOCKWISE - VK_FRONT_FACE_COUNTER_CLOCKWISE + 1),
		VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
	} VkFrontFace;

	typedef enum VkCompareOp {
		VK_COMPARE_OP_NEVER = 0,
		VK_COMPARE_OP_LESS = 1,
		VK_COMPARE_OP_EQUAL = 2,
		VK_COMPARE_OP_LESS_OR_EQUAL = 3,
		VK_COMPARE_OP_GREATER = 4,
		VK_COMPARE_OP_NOT_EQUAL = 5,
		VK_COMPARE_OP_GREATER_OR_EQUAL = 6,
		VK_COMPARE_OP_ALWAYS = 7,
		VK_COMPARE_OP_BEGIN_RANGE = VK_COMPARE_OP_NEVER,
		VK_COMPARE_OP_END_RANGE = VK_COMPARE_OP_ALWAYS,
		VK_COMPARE_OP_RANGE_SIZE = (VK_COMPARE_OP_ALWAYS - VK_COMPARE_OP_NEVER + 1),
		VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
	} VkCompareOp;

	typedef enum VkStencilOp {
		VK_STENCIL_OP_KEEP = 0,
		VK_STENCIL_OP_ZERO = 1,
		VK_STENCIL_OP_REPLACE = 2,
		VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3,
		VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4,
		VK_STENCIL_OP_INVERT = 5,
		VK_STENCIL_OP_INCREMENT_AND_WRAP = 6,
		VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
		VK_STENCIL_OP_BEGIN_RANGE = VK_STENCIL_OP_KEEP,
		VK_STENCIL_OP_END_RANGE = VK_STENCIL_OP_DECREMENT_AND_WRAP,
		VK_STENCIL_OP_RANGE_SIZE = (VK_STENCIL_OP_DECREMENT_AND_WRAP - VK_STENCIL_OP_KEEP + 1),
		VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
	} VkStencilOp;

	typedef enum VkLogicOp {
		VK_LOGIC_OP_CLEAR = 0,
		VK_LOGIC_OP_AND = 1,
		VK_LOGIC_OP_AND_REVERSE = 2,
		VK_LOGIC_OP_COPY = 3,
		VK_LOGIC_OP_AND_INVERTED = 4,
		VK_LOGIC_OP_NO_OP = 5,
		VK_LOGIC_OP_XOR = 6,
		VK_LOGIC_OP_OR = 7,
		VK_LOGIC_OP_NOR = 8,
		VK_LOGIC_OP_EQUIVALENT = 9,
		VK_LOGIC_OP_INVERT = 10,
		VK_LOGIC_OP_OR_REVERSE = 11,
		VK_LOGIC_OP_COPY_INVERTED = 12,
		VK_LOGIC_OP_OR_INVERTED = 13,
		VK_LOGIC_OP_NAND = 14,
		VK_LOGIC_OP_SET = 15,
		VK_LOGIC_OP_BEGIN_RANGE = VK_LOGIC_OP_CLEAR,
		VK_LOGIC_OP_END_RANGE = VK_LOGIC_OP_SET,
		VK_LOGIC_OP_RANGE_SIZE = (VK_LOGIC_OP_SET - VK_LOGIC_OP_CLEAR + 1),
		VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
	} VkLogicOp;

	typedef enum VkBlendFactor {
		VK_BLEND_FACTOR_ZERO = 0,
		VK_BLEND_FACTOR_ONE = 1,
		VK_BLEND_FACTOR_SRC_COLOR = 2,
		VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3,
		VK_BLEND_FACTOR_DST_COLOR = 4,
		VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5,
		VK_BLEND_FACTOR_SRC_ALPHA = 6,
		VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7,
		VK_BLEND_FACTOR_DST_ALPHA = 8,
		VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9,
		VK_BLEND_FACTOR_CONSTANT_COLOR = 10,
		VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11,
		VK_BLEND_FACTOR_CONSTANT_ALPHA = 12,
		VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13,
		VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14,
		VK_BLEND_FACTOR_SRC1_COLOR = 15,
		VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16,
		VK_BLEND_FACTOR_SRC1_ALPHA = 17,
		VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
		VK_BLEND_FACTOR_BEGIN_RANGE = VK_BLEND_FACTOR_ZERO,
		VK_BLEND_FACTOR_END_RANGE = VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA,
		VK_BLEND_FACTOR_RANGE_SIZE = (VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA - VK_BLEND_FACTOR_ZERO + 1),
		VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
	} VkBlendFactor;

	typedef enum VkBlendOp {
		VK_BLEND_OP_ADD = 0,
		VK_BLEND_OP_SUBTRACT = 1,
		VK_BLEND_OP_REVERSE_SUBTRACT = 2,
		VK_BLEND_OP_MIN = 3,
		VK_BLEND_OP_MAX = 4,
		VK_BLEND_OP_BEGIN_RANGE = VK_BLEND_OP_ADD,
		VK_BLEND_OP_END_RANGE = VK_BLEND_OP_MAX,
		VK_BLEND_OP_RANGE_SIZE = (VK_BLEND_OP_MAX - VK_BLEND_OP_ADD + 1),
		VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
	} VkBlendOp;

	typedef enum VkDynamicState {
		VK_DYNAMIC_STATE_VIEWPORT = 0,
		VK_DYNAMIC_STATE_SCISSOR = 1,
		VK_DYNAMIC_STATE_LINE_WIDTH = 2,
		VK_DYNAMIC_STATE_DEPTH_BIAS = 3,
		VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4,
		VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5,
		VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6,
		VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7,
		VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
		VK_DYNAMIC_STATE_BEGIN_RANGE = VK_DYNAMIC_STATE_VIEWPORT,
		VK_DYNAMIC_STATE_END_RANGE = VK_DYNAMIC_STATE_STENCIL_REFERENCE,
		VK_DYNAMIC_STATE_RANGE_SIZE = (VK_DYNAMIC_STATE_STENCIL_REFERENCE - VK_DYNAMIC_STATE_VIEWPORT + 1),
		VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
	} VkDynamicState;

	typedef enum VkFilter {
		VK_FILTER_NEAREST = 0,
		VK_FILTER_LINEAR = 1,
		VK_FILTER_BEGIN_RANGE = VK_FILTER_NEAREST,
		VK_FILTER_END_RANGE = VK_FILTER_LINEAR,
		VK_FILTER_RANGE_SIZE = (VK_FILTER_LINEAR - VK_FILTER_NEAREST + 1),
		VK_FILTER_MAX_ENUM = 0x7FFFFFFF
	} VkFilter;

	typedef enum VkSamplerMipmapMode {
		VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
		VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
		VK_SAMPLER_MIPMAP_MODE_BEGIN_RANGE = VK_SAMPLER_MIPMAP_MODE_NEAREST,
		VK_SAMPLER_MIPMAP_MODE_END_RANGE = VK_SAMPLER_MIPMAP_MODE_LINEAR,
		VK_SAMPLER_MIPMAP_MODE_RANGE_SIZE = (VK_SAMPLER_MIPMAP_MODE_LINEAR - VK_SAMPLER_MIPMAP_MODE_NEAREST + 1),
		VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
	} VkSamplerMipmapMode;

	typedef enum VkSamplerAddressMode {
		VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
		VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
		VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2,
		VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
		VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
		VK_SAMPLER_ADDRESS_MODE_BEGIN_RANGE = VK_SAMPLER_ADDRESS_MODE_REPEAT,
		VK_SAMPLER_ADDRESS_MODE_END_RANGE = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE,
		VK_SAMPLER_ADDRESS_MODE_RANGE_SIZE = (VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE - VK_SAMPLER_ADDRESS_MODE_REPEAT + 1),
		VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
	} VkSamplerAddressMode;

	typedef enum VkBorderColor {
		VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
		VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
		VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2,
		VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3,
		VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4,
		VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
		VK_BORDER_COLOR_BEGIN_RANGE = VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK,
		VK_BORDER_COLOR_END_RANGE = VK_BORDER_COLOR_INT_OPAQUE_WHITE,
		VK_BORDER_COLOR_RANGE_SIZE = (VK_BORDER_COLOR_INT_OPAQUE_WHITE - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK + 1),
		VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
	} VkBorderColor;

	typedef enum VkDescriptorType {
		VK_DESCRIPTOR_TYPE_SAMPLER = 0,
		VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
		VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2,
		VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3,
		VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4,
		VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5,
		VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6,
		VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7,
		VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8,
		VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9,
		VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
		VK_DESCRIPTOR_TYPE_BEGIN_RANGE = VK_DESCRIPTOR_TYPE_SAMPLER,
		VK_DESCRIPTOR_TYPE_END_RANGE = VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT,
		VK_DESCRIPTOR_TYPE_RANGE_SIZE = (VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT - VK_DESCRIPTOR_TYPE_SAMPLER + 1),
		VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkDescriptorType;

	typedef enum VkAttachmentLoadOp {
		VK_ATTACHMENT_LOAD_OP_LOAD = 0,
		VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
		VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
		VK_ATTACHMENT_LOAD_OP_BEGIN_RANGE = VK_ATTACHMENT_LOAD_OP_LOAD,
		VK_ATTACHMENT_LOAD_OP_END_RANGE = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
		VK_ATTACHMENT_LOAD_OP_RANGE_SIZE = (VK_ATTACHMENT_LOAD_OP_DONT_CARE - VK_ATTACHMENT_LOAD_OP_LOAD + 1),
		VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
	} VkAttachmentLoadOp;

	typedef enum VkAttachmentStoreOp {
		VK_ATTACHMENT_STORE_OP_STORE = 0,
		VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
		VK_ATTACHMENT_STORE_OP_BEGIN_RANGE = VK_ATTACHMENT_STORE_OP_STORE,
		VK_ATTACHMENT_STORE_OP_END_RANGE = VK_ATTACHMENT_STORE_OP_DONT_CARE,
		VK_ATTACHMENT_STORE_OP_RANGE_SIZE = (VK_ATTACHMENT_STORE_OP_DONT_CARE - VK_ATTACHMENT_STORE_OP_STORE + 1),
		VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
	} VkAttachmentStoreOp;

	typedef enum VkPipelineBindPoint {
		VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
		VK_PIPELINE_BIND_POINT_COMPUTE = 1,
		VK_PIPELINE_BIND_POINT_BEGIN_RANGE = VK_PIPELINE_BIND_POINT_GRAPHICS,
		VK_PIPELINE_BIND_POINT_END_RANGE = VK_PIPELINE_BIND_POINT_COMPUTE,
		VK_PIPELINE_BIND_POINT_RANGE_SIZE = (VK_PIPELINE_BIND_POINT_COMPUTE - VK_PIPELINE_BIND_POINT_GRAPHICS + 1),
		VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
	} VkPipelineBindPoint;

	typedef enum VkCommandBufferLevel {
		VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
		VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
		VK_COMMAND_BUFFER_LEVEL_BEGIN_RANGE = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
		VK_COMMAND_BUFFER_LEVEL_END_RANGE = VK_COMMAND_BUFFER_LEVEL_SECONDARY,
		VK_COMMAND_BUFFER_LEVEL_RANGE_SIZE = (VK_COMMAND_BUFFER_LEVEL_SECONDARY - VK_COMMAND_BUFFER_LEVEL_PRIMARY + 1),
		VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
	} VkCommandBufferLevel;

	typedef enum VkIndexType {
		VK_INDEX_TYPE_UINT16 = 0,
		VK_INDEX_TYPE_UINT32 = 1,
		VK_INDEX_TYPE_BEGIN_RANGE = VK_INDEX_TYPE_UINT16,
		VK_INDEX_TYPE_END_RANGE = VK_INDEX_TYPE_UINT32,
		VK_INDEX_TYPE_RANGE_SIZE = (VK_INDEX_TYPE_UINT32 - VK_INDEX_TYPE_UINT16 + 1),
		VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
	} VkIndexType;

	typedef enum VkSubpassContents {
		VK_SUBPASS_CONTENTS_INLINE = 0,
		VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
		VK_SUBPASS_CONTENTS_BEGIN_RANGE = VK_SUBPASS_CONTENTS_INLINE,
		VK_SUBPASS_CONTENTS_END_RANGE = VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS,
		VK_SUBPASS_CONTENTS_RANGE_SIZE = (VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS - VK_SUBPASS_CONTENTS_INLINE + 1),
		VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
	} VkSubpassContents;

	typedef VkFlags VkInstanceCreateFlags;

	typedef enum VkFormatFeatureFlagBits {
		VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001,
		VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002,
		VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004,
		VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008,
		VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010,
		VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020,
		VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040,
		VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080,
		VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100,
		VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200,
		VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400,
		VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800,
		VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000,
	} VkFormatFeatureFlagBits;
	typedef VkFlags VkFormatFeatureFlags;

	typedef enum VkImageUsageFlagBits {
		VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001,
		VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002,
		VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004,
		VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008,
		VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010,
		VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020,
		VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040,
		VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080,
	} VkImageUsageFlagBits;
	typedef VkFlags VkImageUsageFlags;

	typedef enum VkImageCreateFlagBits {
		VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001,
		VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
		VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
		VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008,
		VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010,
	} VkImageCreateFlagBits;
	typedef VkFlags VkImageCreateFlags;

	typedef enum VkSampleCountFlagBits {
		VK_SAMPLE_COUNT_1_BIT = 0x00000001,
		VK_SAMPLE_COUNT_2_BIT = 0x00000002,
		VK_SAMPLE_COUNT_4_BIT = 0x00000004,
		VK_SAMPLE_COUNT_8_BIT = 0x00000008,
		VK_SAMPLE_COUNT_16_BIT = 0x00000010,
		VK_SAMPLE_COUNT_32_BIT = 0x00000020,
		VK_SAMPLE_COUNT_64_BIT = 0x00000040,
	} VkSampleCountFlagBits;
	typedef VkFlags VkSampleCountFlags;

	typedef enum VkQueueFlagBits {
		VK_QUEUE_GRAPHICS_BIT = 0x00000001,
		VK_QUEUE_COMPUTE_BIT = 0x00000002,
		VK_QUEUE_TRANSFER_BIT = 0x00000004,
		VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008,
	} VkQueueFlagBits;
	typedef VkFlags VkQueueFlags;

	typedef enum VkMemoryPropertyFlagBits {
		VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001,
		VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002,
		VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004,
		VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008,
		VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010,
	} VkMemoryPropertyFlagBits;
	typedef VkFlags VkMemoryPropertyFlags;

	typedef enum VkMemoryHeapFlagBits {
		VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001,
	} VkMemoryHeapFlagBits;
	typedef VkFlags VkMemoryHeapFlags;
	typedef VkFlags VkDeviceCreateFlags;
	typedef VkFlags VkDeviceQueueCreateFlags;

	typedef enum VkPipelineStageFlagBits {
		VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001,
		VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002,
		VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004,
		VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008,
		VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010,
		VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020,
		VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040,
		VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080,
		VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100,
		VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200,
		VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400,
		VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800,
		VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000,
		VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000,
		VK_PIPELINE_STAGE_HOST_BIT = 0x00004000,
		VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000,
		VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000,
	} VkPipelineStageFlagBits;
	typedef VkFlags VkPipelineStageFlags;
	typedef VkFlags VkMemoryMapFlags;

	typedef enum VkImageAspectFlagBits {
		VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001,
		VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002,
		VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004,
		VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008,
	} VkImageAspectFlagBits;
	typedef VkFlags VkImageAspectFlags;

	typedef enum VkSparseImageFormatFlagBits {
		VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001,
		VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002,
		VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004,
	} VkSparseImageFormatFlagBits;
	typedef VkFlags VkSparseImageFormatFlags;

	typedef enum VkSparseMemoryBindFlagBits {
		VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001,
	} VkSparseMemoryBindFlagBits;
	typedef VkFlags VkSparseMemoryBindFlags;

	typedef enum VkFenceCreateFlagBits {
		VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001,
	} VkFenceCreateFlagBits;
	typedef VkFlags VkFenceCreateFlags;
	typedef VkFlags VkSemaphoreCreateFlags;
	typedef VkFlags VkEventCreateFlags;
	typedef VkFlags VkQueryPoolCreateFlags;

	typedef enum VkQueryPipelineStatisticFlagBits {
		VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001,
		VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002,
		VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004,
		VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008,
		VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010,
		VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020,
		VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040,
		VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080,
		VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100,
		VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200,
		VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400,
	} VkQueryPipelineStatisticFlagBits;
	typedef VkFlags VkQueryPipelineStatisticFlags;

	typedef enum VkQueryResultFlagBits {
		VK_QUERY_RESULT_64_BIT = 0x00000001,
		VK_QUERY_RESULT_WAIT_BIT = 0x00000002,
		VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004,
		VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008,
	} VkQueryResultFlagBits;
	typedef VkFlags VkQueryResultFlags;

	typedef enum VkBufferCreateFlagBits {
		VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001,
		VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002,
		VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004,
	} VkBufferCreateFlagBits;
	typedef VkFlags VkBufferCreateFlags;

	typedef enum VkBufferUsageFlagBits {
		VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001,
		VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002,
		VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004,
		VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008,
		VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010,
		VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020,
		VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040,
		VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080,
		VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100,
	} VkBufferUsageFlagBits;
	typedef VkFlags VkBufferUsageFlags;
	typedef VkFlags VkBufferViewCreateFlags;
	typedef VkFlags VkImageViewCreateFlags;
	typedef VkFlags VkShaderModuleCreateFlags;
	typedef VkFlags VkPipelineCacheCreateFlags;

	typedef enum VkPipelineCreateFlagBits {
		VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001,
		VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002,
		VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004,
	} VkPipelineCreateFlagBits;
	typedef VkFlags VkPipelineCreateFlags;
	typedef VkFlags VkPipelineShaderStageCreateFlags;

	typedef enum VkShaderStageFlagBits {
		VK_SHADER_STAGE_VERTEX_BIT = 0x00000001,
		VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002,
		VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004,
		VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008,
		VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010,
		VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020,
		VK_SHADER_STAGE_ALL_GRAPHICS = 0x1F,
		VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
	} VkShaderStageFlagBits;
	typedef VkFlags VkPipelineVertexInputStateCreateFlags;
	typedef VkFlags VkPipelineInputAssemblyStateCreateFlags;
	typedef VkFlags VkPipelineTessellationStateCreateFlags;
	typedef VkFlags VkPipelineViewportStateCreateFlags;
	typedef VkFlags VkPipelineRasterizationStateCreateFlags;

	typedef enum VkCullModeFlagBits {
		VK_CULL_MODE_NONE = 0,
		VK_CULL_MODE_FRONT_BIT = 0x00000001,
		VK_CULL_MODE_BACK_BIT = 0x00000002,
		VK_CULL_MODE_FRONT_AND_BACK = 0x3,
	} VkCullModeFlagBits;
	typedef VkFlags VkCullModeFlags;
	typedef VkFlags VkPipelineMultisampleStateCreateFlags;
	typedef VkFlags VkPipelineDepthStencilStateCreateFlags;
	typedef VkFlags VkPipelineColorBlendStateCreateFlags;

	typedef enum VkColorComponentFlagBits {
		VK_COLOR_COMPONENT_R_BIT = 0x00000001,
		VK_COLOR_COMPONENT_G_BIT = 0x00000002,
		VK_COLOR_COMPONENT_B_BIT = 0x00000004,
		VK_COLOR_COMPONENT_A_BIT = 0x00000008,
	} VkColorComponentFlagBits;
	typedef VkFlags VkColorComponentFlags;
	typedef VkFlags VkPipelineDynamicStateCreateFlags;
	typedef VkFlags VkPipelineLayoutCreateFlags;
	typedef VkFlags VkShaderStageFlags;
	typedef VkFlags VkSamplerCreateFlags;
	typedef VkFlags VkDescriptorSetLayoutCreateFlags;

	typedef enum VkDescriptorPoolCreateFlagBits {
		VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001,
	} VkDescriptorPoolCreateFlagBits;
	typedef VkFlags VkDescriptorPoolCreateFlags;
	typedef VkFlags VkDescriptorPoolResetFlags;
	typedef VkFlags VkFramebufferCreateFlags;
	typedef VkFlags VkRenderPassCreateFlags;

	typedef enum VkAttachmentDescriptionFlagBits {
		VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001,
	} VkAttachmentDescriptionFlagBits;
	typedef VkFlags VkAttachmentDescriptionFlags;
	typedef VkFlags VkSubpassDescriptionFlags;

	typedef enum VkAccessFlagBits {
		VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001,
		VK_ACCESS_INDEX_READ_BIT = 0x00000002,
		VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004,
		VK_ACCESS_UNIFORM_READ_BIT = 0x00000008,
		VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010,
		VK_ACCESS_SHADER_READ_BIT = 0x00000020,
		VK_ACCESS_SHADER_WRITE_BIT = 0x00000040,
		VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080,
		VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100,
		VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200,
		VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400,
		VK_ACCESS_TRANSFER_READ_BIT = 0x00000800,
		VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000,
		VK_ACCESS_HOST_READ_BIT = 0x00002000,
		VK_ACCESS_HOST_WRITE_BIT = 0x00004000,
		VK_ACCESS_MEMORY_READ_BIT = 0x00008000,
		VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000,
	} VkAccessFlagBits;
	typedef VkFlags VkAccessFlags;

	typedef enum VkDependencyFlagBits {
		VK_DEPENDENCY_BY_REGION_BIT = 0x00000001,
	} VkDependencyFlagBits;
	typedef VkFlags VkDependencyFlags;

	typedef enum VkCommandPoolCreateFlagBits {
		VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001,
		VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002,
	} VkCommandPoolCreateFlagBits;
	typedef VkFlags VkCommandPoolCreateFlags;

	typedef enum VkCommandPoolResetFlagBits {
		VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
	} VkCommandPoolResetFlagBits;
	typedef VkFlags VkCommandPoolResetFlags;

	typedef enum VkCommandBufferUsageFlagBits {
		VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001,
		VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002,
		VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004,
	} VkCommandBufferUsageFlagBits;
	typedef VkFlags VkCommandBufferUsageFlags;

	typedef enum VkQueryControlFlagBits {
		VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001,
	} VkQueryControlFlagBits;
	typedef VkFlags VkQueryControlFlags;

	typedef enum VkCommandBufferResetFlagBits {
		VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001,
	} VkCommandBufferResetFlagBits;
	typedef VkFlags VkCommandBufferResetFlags;

	typedef enum VkStencilFaceFlagBits {
		VK_STENCIL_FACE_FRONT_BIT = 0x00000001,
		VK_STENCIL_FACE_BACK_BIT = 0x00000002,
		VK_STENCIL_FRONT_AND_BACK = 0x3,
	} VkStencilFaceFlagBits;
	typedef VkFlags VkStencilFaceFlags;

	typedef void* (VKAPI_PTR *PFN_vkAllocationFunction)(
		void*                                       pUserData,
		size_t                                      size,
		size_t                                      alignment,
		VkSystemAllocationScope                     allocationScope);

	typedef void* (VKAPI_PTR *PFN_vkReallocationFunction)(
		void*                                       pUserData,
		void*                                       pOriginal,
		size_t                                      size,
		size_t                                      alignment,
		VkSystemAllocationScope                     allocationScope);

	typedef void (VKAPI_PTR *PFN_vkFreeFunction)(
		void*                                       pUserData,
		void*                                       pMemory);

	typedef void (VKAPI_PTR *PFN_vkInternalAllocationNotification)(
		void*                                       pUserData,
		size_t                                      size,
		VkInternalAllocationType                    allocationType,
		VkSystemAllocationScope                     allocationScope);

	typedef void (VKAPI_PTR *PFN_vkInternalFreeNotification)(
		void*                                       pUserData,
		size_t                                      size,
		VkInternalAllocationType                    allocationType,
		VkSystemAllocationScope                     allocationScope);

	typedef void (VKAPI_PTR *PFN_vkVoidFunction)(void);

	typedef struct VkApplicationInfo {
		VkStructureType    sType;
		const void*        pNext;
		const char*        pApplicationName;
		uint32_t           applicationVersion;
		const char*        pEngineName;
		uint32_t           engineVersion;
		uint32_t           apiVersion;
	} VkApplicationInfo;

	typedef struct VkInstanceCreateInfo {
		VkStructureType             sType;
		const void*                 pNext;
		VkInstanceCreateFlags       flags;
		const VkApplicationInfo*    pApplicationInfo;
		uint32_t                    enabledLayerCount;
		const char* const*          ppEnabledLayerNames;
		uint32_t                    enabledExtensionCount;
		const char* const*          ppEnabledExtensionNames;
	} VkInstanceCreateInfo;

	typedef struct VkAllocationCallbacks {
		void*                                   pUserData;
		PFN_vkAllocationFunction                pfnAllocation;
		PFN_vkReallocationFunction              pfnReallocation;
		PFN_vkFreeFunction                      pfnFree;
		PFN_vkInternalAllocationNotification    pfnInternalAllocation;
		PFN_vkInternalFreeNotification          pfnInternalFree;
	} VkAllocationCallbacks;

	typedef struct VkPhysicalDeviceFeatures {
		VkBool32    robustBufferAccess;
		VkBool32    fullDrawIndexUint32;
		VkBool32    imageCubeArray;
		VkBool32    independentBlend;
		VkBool32    geometryShader;
		VkBool32    tessellationShader;
		VkBool32    sampleRateShading;
		VkBool32    dualSrcBlend;
		VkBool32    logicOp;
		VkBool32    multiDrawIndirect;
		VkBool32    drawIndirectFirstInstance;
		VkBool32    depthClamp;
		VkBool32    depthBiasClamp;
		VkBool32    fillModeNonSolid;
		VkBool32    depthBounds;
		VkBool32    wideLines;
		VkBool32    largePoints;
		VkBool32    alphaToOne;
		VkBool32    multiViewport;
		VkBool32    samplerAnisotropy;
		VkBool32    textureCompressionETC2;
		VkBool32    textureCompressionASTC_LDR;
		VkBool32    textureCompressionBC;
		VkBool32    occlusionQueryPrecise;
		VkBool32    pipelineStatisticsQuery;
		VkBool32    vertexPipelineStoresAndAtomics;
		VkBool32    fragmentStoresAndAtomics;
		VkBool32    shaderTessellationAndGeometryPointSize;
		VkBool32    shaderImageGatherExtended;
		VkBool32    shaderStorageImageExtendedFormats;
		VkBool32    shaderStorageImageMultisample;
		VkBool32    shaderStorageImageReadWithoutFormat;
		VkBool32    shaderStorageImageWriteWithoutFormat;
		VkBool32    shaderUniformBufferArrayDynamicIndexing;
		VkBool32    shaderSampledImageArrayDynamicIndexing;
		VkBool32    shaderStorageBufferArrayDynamicIndexing;
		VkBool32    shaderStorageImageArrayDynamicIndexing;
		VkBool32    shaderClipDistance;
		VkBool32    shaderCullDistance;
		VkBool32    shaderFloat64;
		VkBool32    shaderInt64;
		VkBool32    shaderInt16;
		VkBool32    shaderResourceResidency;
		VkBool32    shaderResourceMinLod;
		VkBool32    sparseBinding;
		VkBool32    sparseResidencyBuffer;
		VkBool32    sparseResidencyImage2D;
		VkBool32    sparseResidencyImage3D;
		VkBool32    sparseResidency2Samples;
		VkBool32    sparseResidency4Samples;
		VkBool32    sparseResidency8Samples;
		VkBool32    sparseResidency16Samples;
		VkBool32    sparseResidencyAliased;
		VkBool32    variableMultisampleRate;
		VkBool32    inheritedQueries;
	} VkPhysicalDeviceFeatures;

	typedef struct VkFormatProperties {
		VkFormatFeatureFlags    linearTilingFeatures;
		VkFormatFeatureFlags    optimalTilingFeatures;
		VkFormatFeatureFlags    bufferFeatures;
	} VkFormatProperties;

	typedef struct VkExtent3D {
		uint32_t    width;
		uint32_t    height;
		uint32_t    depth;
	} VkExtent3D;

	typedef struct VkImageFormatProperties {
		VkExtent3D            maxExtent;
		uint32_t              maxMipLevels;
		uint32_t              maxArrayLayers;
		VkSampleCountFlags    sampleCounts;
		VkDeviceSize          maxResourceSize;
	} VkImageFormatProperties;

	typedef struct VkPhysicalDeviceLimits {
		uint32_t              maxImageDimension1D;
		uint32_t              maxImageDimension2D;
		uint32_t              maxImageDimension3D;
		uint32_t              maxImageDimensionCube;
		uint32_t              maxImageArrayLayers;
		uint32_t              maxTexelBufferElements;
		uint32_t              maxUniformBufferRange;
		uint32_t              maxStorageBufferRange;
		uint32_t              maxPushConstantsSize;
		uint32_t              maxMemoryAllocationCount;
		uint32_t              maxSamplerAllocationCount;
		VkDeviceSize          bufferImageGranularity;
		VkDeviceSize          sparseAddressSpaceSize;
		uint32_t              maxBoundDescriptorSets;
		uint32_t              maxPerStageDescriptorSamplers;
		uint32_t              maxPerStageDescriptorUniformBuffers;
		uint32_t              maxPerStageDescriptorStorageBuffers;
		uint32_t              maxPerStageDescriptorSampledImages;
		uint32_t              maxPerStageDescriptorStorageImages;
		uint32_t              maxPerStageDescriptorInputAttachments;
		uint32_t              maxPerStageResources;
		uint32_t              maxDescriptorSetSamplers;
		uint32_t              maxDescriptorSetUniformBuffers;
		uint32_t              maxDescriptorSetUniformBuffersDynamic;
		uint32_t              maxDescriptorSetStorageBuffers;
		uint32_t              maxDescriptorSetStorageBuffersDynamic;
		uint32_t              maxDescriptorSetSampledImages;
		uint32_t              maxDescriptorSetStorageImages;
		uint32_t              maxDescriptorSetInputAttachments;
		uint32_t              maxVertexInputAttributes;
		uint32_t              maxVertexInputBindings;
		uint32_t              maxVertexInputAttributeOffset;
		uint32_t              maxVertexInputBindingStride;
		uint32_t              maxVertexOutputComponents;
		uint32_t              maxTessellationGenerationLevel;
		uint32_t              maxTessellationPatchSize;
		uint32_t              maxTessellationControlPerVertexInputComponents;
		uint32_t              maxTessellationControlPerVertexOutputComponents;
		uint32_t              maxTessellationControlPerPatchOutputComponents;
		uint32_t              maxTessellationControlTotalOutputComponents;
		uint32_t              maxTessellationEvaluationInputComponents;
		uint32_t              maxTessellationEvaluationOutputComponents;
		uint32_t              maxGeometryShaderInvocations;
		uint32_t              maxGeometryInputComponents;
		uint32_t              maxGeometryOutputComponents;
		uint32_t              maxGeometryOutputVertices;
		uint32_t              maxGeometryTotalOutputComponents;
		uint32_t              maxFragmentInputComponents;
		uint32_t              maxFragmentOutputAttachments;
		uint32_t              maxFragmentDualSrcAttachments;
		uint32_t              maxFragmentCombinedOutputResources;
		uint32_t              maxComputeSharedMemorySize;
		uint32_t              maxComputeWorkGroupCount[3];
		uint32_t              maxComputeWorkGroupInvocations;
		uint32_t              maxComputeWorkGroupSize[3];
		uint32_t              subPixelPrecisionBits;
		uint32_t              subTexelPrecisionBits;
		uint32_t              mipmapPrecisionBits;
		uint32_t              maxDrawIndexedIndexValue;
		uint32_t              maxDrawIndirectCount;
		float                 maxSamplerLodBias;
		float                 maxSamplerAnisotropy;
		uint32_t              maxViewports;
		uint32_t              maxViewportDimensions[2];
		float                 viewportBoundsRange[2];
		uint32_t              viewportSubPixelBits;
		size_t                minMemoryMapAlignment;
		VkDeviceSize          minTexelBufferOffsetAlignment;
		VkDeviceSize          minUniformBufferOffsetAlignment;
		VkDeviceSize          minStorageBufferOffsetAlignment;
		int32_t               minTexelOffset;
		uint32_t              maxTexelOffset;
		int32_t               minTexelGatherOffset;
		uint32_t              maxTexelGatherOffset;
		float                 minInterpolationOffset;
		float                 maxInterpolationOffset;
		uint32_t              subPixelInterpolationOffsetBits;
		uint32_t              maxFramebufferWidth;
		uint32_t              maxFramebufferHeight;
		uint32_t              maxFramebufferLayers;
		VkSampleCountFlags    framebufferColorSampleCounts;
		VkSampleCountFlags    framebufferDepthSampleCounts;
		VkSampleCountFlags    framebufferStencilSampleCounts;
		VkSampleCountFlags    framebufferNoAttachmentsSampleCounts;
		uint32_t              maxColorAttachments;
		VkSampleCountFlags    sampledImageColorSampleCounts;
		VkSampleCountFlags    sampledImageIntegerSampleCounts;
		VkSampleCountFlags    sampledImageDepthSampleCounts;
		VkSampleCountFlags    sampledImageStencilSampleCounts;
		VkSampleCountFlags    storageImageSampleCounts;
		uint32_t              maxSampleMaskWords;
		VkBool32              timestampComputeAndGraphics;
		float                 timestampPeriod;
		uint32_t              maxClipDistances;
		uint32_t              maxCullDistances;
		uint32_t              maxCombinedClipAndCullDistances;
		uint32_t              discreteQueuePriorities;
		float                 pointSizeRange[2];
		float                 lineWidthRange[2];
		float                 pointSizeGranularity;
		float                 lineWidthGranularity;
		VkBool32              strictLines;
		VkBool32              standardSampleLocations;
		VkDeviceSize          optimalBufferCopyOffsetAlignment;
		VkDeviceSize          optimalBufferCopyRowPitchAlignment;
		VkDeviceSize          nonCoherentAtomSize;
	} VkPhysicalDeviceLimits;

	typedef struct VkPhysicalDeviceSparseProperties {
		VkBool32    residencyStandard2DBlockShape;
		VkBool32    residencyStandard2DMultisampleBlockShape;
		VkBool32    residencyStandard3DBlockShape;
		VkBool32    residencyAlignedMipSize;
		VkBool32    residencyNonResidentStrict;
	} VkPhysicalDeviceSparseProperties;

	typedef struct VkPhysicalDeviceProperties {
		uint32_t                            apiVersion;
		uint32_t                            driverVersion;
		uint32_t                            vendorID;
		uint32_t                            deviceID;
		VkPhysicalDeviceType                deviceType;
		char                                deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
		uint8_t                             pipelineCacheUUID[VK_UUID_SIZE];
		VkPhysicalDeviceLimits              limits;
		VkPhysicalDeviceSparseProperties    sparseProperties;
	} VkPhysicalDeviceProperties;

	typedef struct VkQueueFamilyProperties {
		VkQueueFlags    queueFlags;
		uint32_t        queueCount;
		uint32_t        timestampValidBits;
		VkExtent3D      minImageTransferGranularity;
	} VkQueueFamilyProperties;

	typedef struct VkMemoryType {
		VkMemoryPropertyFlags    propertyFlags;
		uint32_t                 heapIndex;
	} VkMemoryType;

	typedef struct VkMemoryHeap {
		VkDeviceSize         size;
		VkMemoryHeapFlags    flags;
	} VkMemoryHeap;

	typedef struct VkPhysicalDeviceMemoryProperties {
		uint32_t        memoryTypeCount;
		VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
		uint32_t        memoryHeapCount;
		VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
	} VkPhysicalDeviceMemoryProperties;

	typedef struct VkDeviceQueueCreateInfo {
		VkStructureType             sType;
		const void*                 pNext;
		VkDeviceQueueCreateFlags    flags;
		uint32_t                    queueFamilyIndex;
		uint32_t                    queueCount;
		const float*                pQueuePriorities;
	} VkDeviceQueueCreateInfo;

	typedef struct VkDeviceCreateInfo {
		VkStructureType                    sType;
		const void*                        pNext;
		VkDeviceCreateFlags                flags;
		uint32_t                           queueCreateInfoCount;
		const VkDeviceQueueCreateInfo*     pQueueCreateInfos;
		uint32_t                           enabledLayerCount;
		const char* const*                 ppEnabledLayerNames;
		uint32_t                           enabledExtensionCount;
		const char* const*                 ppEnabledExtensionNames;
		const VkPhysicalDeviceFeatures*    pEnabledFeatures;
	} VkDeviceCreateInfo;

	typedef struct VkExtensionProperties {
		char        extensionName[VK_MAX_EXTENSION_NAME_SIZE];
		uint32_t    specVersion;
	} VkExtensionProperties;

	typedef struct VkLayerProperties {
		char        layerName[VK_MAX_EXTENSION_NAME_SIZE];
		uint32_t    specVersion;
		uint32_t    implementationVersion;
		char        description[VK_MAX_DESCRIPTION_SIZE];
	} VkLayerProperties;

	typedef struct VkSubmitInfo {
		VkStructureType                sType;
		const void*                    pNext;
		uint32_t                       waitSemaphoreCount;
		const VkSemaphore*             pWaitSemaphores;
		const VkPipelineStageFlags*    pWaitDstStageMask;
		uint32_t                       commandBufferCount;
		const VkCommandBuffer*         pCommandBuffers;
		uint32_t                       signalSemaphoreCount;
		const VkSemaphore*             pSignalSemaphores;
	} VkSubmitInfo;

	typedef struct VkMemoryAllocateInfo {
		VkStructureType    sType;
		const void*        pNext;
		VkDeviceSize       allocationSize;
		uint32_t           memoryTypeIndex;
	} VkMemoryAllocateInfo;

	typedef struct VkMappedMemoryRange {
		VkStructureType    sType;
		const void*        pNext;
		VkDeviceMemory     memory;
		VkDeviceSize       offset;
		VkDeviceSize       size;
	} VkMappedMemoryRange;

	typedef struct VkMemoryRequirements {
		VkDeviceSize    size;
		VkDeviceSize    alignment;
		uint32_t        memoryTypeBits;
	} VkMemoryRequirements;

	typedef struct VkSparseImageFormatProperties {
		VkImageAspectFlags          aspectMask;
		VkExtent3D                  imageGranularity;
		VkSparseImageFormatFlags    flags;
	} VkSparseImageFormatProperties;

	typedef struct VkSparseImageMemoryRequirements {
		VkSparseImageFormatProperties    formatProperties;
		uint32_t                         imageMipTailFirstLod;
		VkDeviceSize                     imageMipTailSize;
		VkDeviceSize                     imageMipTailOffset;
		VkDeviceSize                     imageMipTailStride;
	} VkSparseImageMemoryRequirements;

	typedef struct VkSparseMemoryBind {
		VkDeviceSize               resourceOffset;
		VkDeviceSize               size;
		VkDeviceMemory             memory;
		VkDeviceSize               memoryOffset;
		VkSparseMemoryBindFlags    flags;
	} VkSparseMemoryBind;

	typedef struct VkSparseBufferMemoryBindInfo {
		VkBuffer                     buffer;
		uint32_t                     bindCount;
		const VkSparseMemoryBind*    pBinds;
	} VkSparseBufferMemoryBindInfo;

	typedef struct VkSparseImageOpaqueMemoryBindInfo {
		VkImage                      image;
		uint32_t                     bindCount;
		const VkSparseMemoryBind*    pBinds;
	} VkSparseImageOpaqueMemoryBindInfo;

	typedef struct VkImageSubresource {
		VkImageAspectFlags    aspectMask;
		uint32_t              mipLevel;
		uint32_t              arrayLayer;
	} VkImageSubresource;

	typedef struct VkOffset3D {
		int32_t    x;
		int32_t    y;
		int32_t    z;
	} VkOffset3D;

	typedef struct VkSparseImageMemoryBind {
		VkImageSubresource         subresource;
		VkOffset3D                 offset;
		VkExtent3D                 extent;
		VkDeviceMemory             memory;
		VkDeviceSize               memoryOffset;
		VkSparseMemoryBindFlags    flags;
	} VkSparseImageMemoryBind;

	typedef struct VkSparseImageMemoryBindInfo {
		VkImage                           image;
		uint32_t                          bindCount;
		const VkSparseImageMemoryBind*    pBinds;
	} VkSparseImageMemoryBindInfo;

	typedef struct VkBindSparseInfo {
		VkStructureType                             sType;
		const void*                                 pNext;
		uint32_t                                    waitSemaphoreCount;
		const VkSemaphore*                          pWaitSemaphores;
		uint32_t                                    bufferBindCount;
		const VkSparseBufferMemoryBindInfo*         pBufferBinds;
		uint32_t                                    imageOpaqueBindCount;
		const VkSparseImageOpaqueMemoryBindInfo*    pImageOpaqueBinds;
		uint32_t                                    imageBindCount;
		const VkSparseImageMemoryBindInfo*          pImageBinds;
		uint32_t                                    signalSemaphoreCount;
		const VkSemaphore*                          pSignalSemaphores;
	} VkBindSparseInfo;

	typedef struct VkFenceCreateInfo {
		VkStructureType       sType;
		const void*           pNext;
		VkFenceCreateFlags    flags;
	} VkFenceCreateInfo;

	typedef struct VkSemaphoreCreateInfo {
		VkStructureType           sType;
		const void*               pNext;
		VkSemaphoreCreateFlags    flags;
	} VkSemaphoreCreateInfo;

	typedef struct VkEventCreateInfo {
		VkStructureType       sType;
		const void*           pNext;
		VkEventCreateFlags    flags;
	} VkEventCreateInfo;

	typedef struct VkQueryPoolCreateInfo {
		VkStructureType                  sType;
		const void*                      pNext;
		VkQueryPoolCreateFlags           flags;
		VkQueryType                      queryType;
		uint32_t                         queryCount;
		VkQueryPipelineStatisticFlags    pipelineStatistics;
	} VkQueryPoolCreateInfo;

	typedef struct VkBufferCreateInfo {
		VkStructureType        sType;
		const void*            pNext;
		VkBufferCreateFlags    flags;
		VkDeviceSize           size;
		VkBufferUsageFlags     usage;
		VkSharingMode          sharingMode;
		uint32_t               queueFamilyIndexCount;
		const uint32_t*        pQueueFamilyIndices;
	} VkBufferCreateInfo;

	typedef struct VkBufferViewCreateInfo {
		VkStructureType            sType;
		const void*                pNext;
		VkBufferViewCreateFlags    flags;
		VkBuffer                   buffer;
		VkFormat                   format;
		VkDeviceSize               offset;
		VkDeviceSize               range;
	} VkBufferViewCreateInfo;

	typedef struct VkImageCreateInfo {
		VkStructureType          sType;
		const void*              pNext;
		VkImageCreateFlags       flags;
		VkImageType              imageType;
		VkFormat                 format;
		VkExtent3D               extent;
		uint32_t                 mipLevels;
		uint32_t                 arrayLayers;
		VkSampleCountFlagBits    samples;
		VkImageTiling            tiling;
		VkImageUsageFlags        usage;
		VkSharingMode            sharingMode;
		uint32_t                 queueFamilyIndexCount;
		const uint32_t*          pQueueFamilyIndices;
		VkImageLayout            initialLayout;
	} VkImageCreateInfo;

	typedef struct VkSubresourceLayout {
		VkDeviceSize    offset;
		VkDeviceSize    size;
		VkDeviceSize    rowPitch;
		VkDeviceSize    arrayPitch;
		VkDeviceSize    depthPitch;
	} VkSubresourceLayout;

	typedef struct VkComponentMapping {
		VkComponentSwizzle    r;
		VkComponentSwizzle    g;
		VkComponentSwizzle    b;
		VkComponentSwizzle    a;
	} VkComponentMapping;

	typedef struct VkImageSubresourceRange {
		VkImageAspectFlags    aspectMask;
		uint32_t              baseMipLevel;
		uint32_t              levelCount;
		uint32_t              baseArrayLayer;
		uint32_t              layerCount;
	} VkImageSubresourceRange;

	typedef struct VkImageViewCreateInfo {
		VkStructureType            sType;
		const void*                pNext;
		VkImageViewCreateFlags     flags;
		VkImage                    image;
		VkImageViewType            viewType;
		VkFormat                   format;
		VkComponentMapping         components;
		VkImageSubresourceRange    subresourceRange;
	} VkImageViewCreateInfo;

	typedef struct VkShaderModuleCreateInfo {
		VkStructureType              sType;
		const void*                  pNext;
		VkShaderModuleCreateFlags    flags;
		size_t                       codeSize;
		const uint32_t*              pCode;
	} VkShaderModuleCreateInfo;

	typedef struct VkPipelineCacheCreateInfo {
		VkStructureType               sType;
		const void*                   pNext;
		VkPipelineCacheCreateFlags    flags;
		size_t                        initialDataSize;
		const void*                   pInitialData;
	} VkPipelineCacheCreateInfo;

	typedef struct VkSpecializationMapEntry {
		uint32_t    constantID;
		uint32_t    offset;
		size_t      size;
	} VkSpecializationMapEntry;

	typedef struct VkSpecializationInfo {
		uint32_t                           mapEntryCount;
		const VkSpecializationMapEntry*    pMapEntries;
		size_t                             dataSize;
		const void*                        pData;
	} VkSpecializationInfo;

	typedef struct VkPipelineShaderStageCreateInfo {
		VkStructureType                     sType;
		const void*                         pNext;
		VkPipelineShaderStageCreateFlags    flags;
		VkShaderStageFlagBits               stage;
		VkShaderModule                      module;
		const char*                         pName;
		const VkSpecializationInfo*         pSpecializationInfo;
	} VkPipelineShaderStageCreateInfo;

	typedef struct VkVertexInputBindingDescription {
		uint32_t             binding;
		uint32_t             stride;
		VkVertexInputRate    inputRate;
	} VkVertexInputBindingDescription;

	typedef struct VkVertexInputAttributeDescription {
		uint32_t    location;
		uint32_t    binding;
		VkFormat    format;
		uint32_t    offset;
	} VkVertexInputAttributeDescription;

	typedef struct VkPipelineVertexInputStateCreateInfo {
		VkStructureType                             sType;
		const void*                                 pNext;
		VkPipelineVertexInputStateCreateFlags       flags;
		uint32_t                                    vertexBindingDescriptionCount;
		const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
		uint32_t                                    vertexAttributeDescriptionCount;
		const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
	} VkPipelineVertexInputStateCreateInfo;

	typedef struct VkPipelineInputAssemblyStateCreateInfo {
		VkStructureType                            sType;
		const void*                                pNext;
		VkPipelineInputAssemblyStateCreateFlags    flags;
		VkPrimitiveTopology                        topology;
		VkBool32                                   primitiveRestartEnable;
	} VkPipelineInputAssemblyStateCreateInfo;

	typedef struct VkPipelineTessellationStateCreateInfo {
		VkStructureType                           sType;
		const void*                               pNext;
		VkPipelineTessellationStateCreateFlags    flags;
		uint32_t                                  patchControlPoints;
	} VkPipelineTessellationStateCreateInfo;

	typedef struct VkViewport {
		float    x;
		float    y;
		float    width;
		float    height;
		float    minDepth;
		float    maxDepth;
	} VkViewport;

	typedef struct VkOffset2D {
		int32_t    x;
		int32_t    y;
	} VkOffset2D;

	typedef struct VkExtent2D {
		uint32_t    width;
		uint32_t    height;
	} VkExtent2D;

	typedef struct VkRect2D {
		VkOffset2D    offset;
		VkExtent2D    extent;
	} VkRect2D;

	typedef struct VkPipelineViewportStateCreateInfo {
		VkStructureType                       sType;
		const void*                           pNext;
		VkPipelineViewportStateCreateFlags    flags;
		uint32_t                              viewportCount;
		const VkViewport*                     pViewports;
		uint32_t                              scissorCount;
		const VkRect2D*                       pScissors;
	} VkPipelineViewportStateCreateInfo;

	typedef struct VkPipelineRasterizationStateCreateInfo {
		VkStructureType                            sType;
		const void*                                pNext;
		VkPipelineRasterizationStateCreateFlags    flags;
		VkBool32                                   depthClampEnable;
		VkBool32                                   rasterizerDiscardEnable;
		VkPolygonMode                              polygonMode;
		VkCullModeFlags                            cullMode;
		VkFrontFace                                frontFace;
		VkBool32                                   depthBiasEnable;
		float                                      depthBiasConstantFactor;
		float                                      depthBiasClamp;
		float                                      depthBiasSlopeFactor;
		float                                      lineWidth;
	} VkPipelineRasterizationStateCreateInfo;

	typedef struct VkPipelineMultisampleStateCreateInfo {
		VkStructureType                          sType;
		const void*                              pNext;
		VkPipelineMultisampleStateCreateFlags    flags;
		VkSampleCountFlagBits                    rasterizationSamples;
		VkBool32                                 sampleShadingEnable;
		float                                    minSampleShading;
		const VkSampleMask*                      pSampleMask;
		VkBool32                                 alphaToCoverageEnable;
		VkBool32                                 alphaToOneEnable;
	} VkPipelineMultisampleStateCreateInfo;

	typedef struct VkStencilOpState {
		VkStencilOp    failOp;
		VkStencilOp    passOp;
		VkStencilOp    depthFailOp;
		VkCompareOp    compareOp;
		uint32_t       compareMask;
		uint32_t       writeMask;
		uint32_t       reference;
	} VkStencilOpState;

	typedef struct VkPipelineDepthStencilStateCreateInfo {
		VkStructureType                           sType;
		const void*                               pNext;
		VkPipelineDepthStencilStateCreateFlags    flags;
		VkBool32                                  depthTestEnable;
		VkBool32                                  depthWriteEnable;
		VkCompareOp                               depthCompareOp;
		VkBool32                                  depthBoundsTestEnable;
		VkBool32                                  stencilTestEnable;
		VkStencilOpState                          front;
		VkStencilOpState                          back;
		float                                     minDepthBounds;
		float                                     maxDepthBounds;
	} VkPipelineDepthStencilStateCreateInfo;

	typedef struct VkPipelineColorBlendAttachmentState {
		VkBool32                 blendEnable;
		VkBlendFactor            srcColorBlendFactor;
		VkBlendFactor            dstColorBlendFactor;
		VkBlendOp                colorBlendOp;
		VkBlendFactor            srcAlphaBlendFactor;
		VkBlendFactor            dstAlphaBlendFactor;
		VkBlendOp                alphaBlendOp;
		VkColorComponentFlags    colorWriteMask;
	} VkPipelineColorBlendAttachmentState;

	typedef struct VkPipelineColorBlendStateCreateInfo {
		VkStructureType                               sType;
		const void*                                   pNext;
		VkPipelineColorBlendStateCreateFlags          flags;
		VkBool32                                      logicOpEnable;
		VkLogicOp                                     logicOp;
		uint32_t                                      attachmentCount;
		const VkPipelineColorBlendAttachmentState*    pAttachments;
		float                                         blendConstants[4];
	} VkPipelineColorBlendStateCreateInfo;

	typedef struct VkPipelineDynamicStateCreateInfo {
		VkStructureType                      sType;
		const void*                          pNext;
		VkPipelineDynamicStateCreateFlags    flags;
		uint32_t                             dynamicStateCount;
		const VkDynamicState*                pDynamicStates;
	} VkPipelineDynamicStateCreateInfo;

	typedef struct VkGraphicsPipelineCreateInfo {
		VkStructureType                                  sType;
		const void*                                      pNext;
		VkPipelineCreateFlags                            flags;
		uint32_t                                         stageCount;
		const VkPipelineShaderStageCreateInfo*           pStages;
		const VkPipelineVertexInputStateCreateInfo*      pVertexInputState;
		const VkPipelineInputAssemblyStateCreateInfo*    pInputAssemblyState;
		const VkPipelineTessellationStateCreateInfo*     pTessellationState;
		const VkPipelineViewportStateCreateInfo*         pViewportState;
		const VkPipelineRasterizationStateCreateInfo*    pRasterizationState;
		const VkPipelineMultisampleStateCreateInfo*      pMultisampleState;
		const VkPipelineDepthStencilStateCreateInfo*     pDepthStencilState;
		const VkPipelineColorBlendStateCreateInfo*       pColorBlendState;
		const VkPipelineDynamicStateCreateInfo*          pDynamicState;
		VkPipelineLayout                                 layout;
		VkRenderPass                                     renderPass;
		uint32_t                                         subpass;
		VkPipeline                                       basePipelineHandle;
		int32_t                                          basePipelineIndex;
	} VkGraphicsPipelineCreateInfo;

	typedef struct VkComputePipelineCreateInfo {
		VkStructureType                    sType;
		const void*                        pNext;
		VkPipelineCreateFlags              flags;
		VkPipelineShaderStageCreateInfo    stage;
		VkPipelineLayout                   layout;
		VkPipeline                         basePipelineHandle;
		int32_t                            basePipelineIndex;
	} VkComputePipelineCreateInfo;

	typedef struct VkPushConstantRange {
		VkShaderStageFlags    stageFlags;
		uint32_t              offset;
		uint32_t              size;
	} VkPushConstantRange;

	typedef struct VkPipelineLayoutCreateInfo {
		VkStructureType                 sType;
		const void*                     pNext;
		VkPipelineLayoutCreateFlags     flags;
		uint32_t                        setLayoutCount;
		const VkDescriptorSetLayout*    pSetLayouts;
		uint32_t                        pushConstantRangeCount;
		const VkPushConstantRange*      pPushConstantRanges;
	} VkPipelineLayoutCreateInfo;

	typedef struct VkSamplerCreateInfo {
		VkStructureType         sType;
		const void*             pNext;
		VkSamplerCreateFlags    flags;
		VkFilter                magFilter;
		VkFilter                minFilter;
		VkSamplerMipmapMode     mipmapMode;
		VkSamplerAddressMode    addressModeU;
		VkSamplerAddressMode    addressModeV;
		VkSamplerAddressMode    addressModeW;
		float                   mipLodBias;
		VkBool32                anisotropyEnable;
		float                   maxAnisotropy;
		VkBool32                compareEnable;
		VkCompareOp             compareOp;
		float                   minLod;
		float                   maxLod;
		VkBorderColor           borderColor;
		VkBool32                unnormalizedCoordinates;
	} VkSamplerCreateInfo;

	typedef struct VkDescriptorSetLayoutBinding {
		uint32_t              binding;
		VkDescriptorType      descriptorType;
		uint32_t              descriptorCount;
		VkShaderStageFlags    stageFlags;
		const VkSampler*      pImmutableSamplers;
	} VkDescriptorSetLayoutBinding;

	typedef struct VkDescriptorSetLayoutCreateInfo {
		VkStructureType                        sType;
		const void*                            pNext;
		VkDescriptorSetLayoutCreateFlags       flags;
		uint32_t                               bindingCount;
		const VkDescriptorSetLayoutBinding*    pBindings;
	} VkDescriptorSetLayoutCreateInfo;

	typedef struct VkDescriptorPoolSize {
		VkDescriptorType    type;
		uint32_t            descriptorCount;
	} VkDescriptorPoolSize;

	typedef struct VkDescriptorPoolCreateInfo {
		VkStructureType                sType;
		const void*                    pNext;
		VkDescriptorPoolCreateFlags    flags;
		uint32_t                       maxSets;
		uint32_t                       poolSizeCount;
		const VkDescriptorPoolSize*    pPoolSizes;
	} VkDescriptorPoolCreateInfo;

	typedef struct VkDescriptorSetAllocateInfo {
		VkStructureType                 sType;
		const void*                     pNext;
		VkDescriptorPool                descriptorPool;
		uint32_t                        descriptorSetCount;
		const VkDescriptorSetLayout*    pSetLayouts;
	} VkDescriptorSetAllocateInfo;

	typedef struct VkDescriptorImageInfo {
		VkSampler        sampler;
		VkImageView      imageView;
		VkImageLayout    imageLayout;
	} VkDescriptorImageInfo;

	typedef struct VkDescriptorBufferInfo {
		VkBuffer        buffer;
		VkDeviceSize    offset;
		VkDeviceSize    range;
	} VkDescriptorBufferInfo;

	typedef struct VkWriteDescriptorSet {
		VkStructureType                  sType;
		const void*                      pNext;
		VkDescriptorSet                  dstSet;
		uint32_t                         dstBinding;
		uint32_t                         dstArrayElement;
		uint32_t                         descriptorCount;
		VkDescriptorType                 descriptorType;
		const VkDescriptorImageInfo*     pImageInfo;
		const VkDescriptorBufferInfo*    pBufferInfo;
		const VkBufferView*              pTexelBufferView;
	} VkWriteDescriptorSet;

	typedef struct VkCopyDescriptorSet {
		VkStructureType    sType;
		const void*        pNext;
		VkDescriptorSet    srcSet;
		uint32_t           srcBinding;
		uint32_t           srcArrayElement;
		VkDescriptorSet    dstSet;
		uint32_t           dstBinding;
		uint32_t           dstArrayElement;
		uint32_t           descriptorCount;
	} VkCopyDescriptorSet;

	typedef struct VkFramebufferCreateInfo {
		VkStructureType             sType;
		const void*                 pNext;
		VkFramebufferCreateFlags    flags;
		VkRenderPass                renderPass;
		uint32_t                    attachmentCount;
		const VkImageView*          pAttachments;
		uint32_t                    width;
		uint32_t                    height;
		uint32_t                    layers;
	} VkFramebufferCreateInfo;

	typedef struct VkAttachmentDescription {
		VkAttachmentDescriptionFlags    flags;
		VkFormat                        format;
		VkSampleCountFlagBits           samples;
		VkAttachmentLoadOp              loadOp;
		VkAttachmentStoreOp             storeOp;
		VkAttachmentLoadOp              stencilLoadOp;
		VkAttachmentStoreOp             stencilStoreOp;
		VkImageLayout                   initialLayout;
		VkImageLayout                   finalLayout;
	} VkAttachmentDescription;

	typedef struct VkAttachmentReference {
		uint32_t         attachment;
		VkImageLayout    layout;
	} VkAttachmentReference;

	typedef struct VkSubpassDescription {
		VkSubpassDescriptionFlags       flags;
		VkPipelineBindPoint             pipelineBindPoint;
		uint32_t                        inputAttachmentCount;
		const VkAttachmentReference*    pInputAttachments;
		uint32_t                        colorAttachmentCount;
		const VkAttachmentReference*    pColorAttachments;
		const VkAttachmentReference*    pResolveAttachments;
		const VkAttachmentReference*    pDepthStencilAttachment;
		uint32_t                        preserveAttachmentCount;
		const uint32_t*                 pPreserveAttachments;
	} VkSubpassDescription;

	typedef struct VkSubpassDependency {
		uint32_t                srcSubpass;
		uint32_t                dstSubpass;
		VkPipelineStageFlags    srcStageMask;
		VkPipelineStageFlags    dstStageMask;
		VkAccessFlags           srcAccessMask;
		VkAccessFlags           dstAccessMask;
		VkDependencyFlags       dependencyFlags;
	} VkSubpassDependency;

	typedef struct VkRenderPassCreateInfo {
		VkStructureType                   sType;
		const void*                       pNext;
		VkRenderPassCreateFlags           flags;
		uint32_t                          attachmentCount;
		const VkAttachmentDescription*    pAttachments;
		uint32_t                          subpassCount;
		const VkSubpassDescription*       pSubpasses;
		uint32_t                          dependencyCount;
		const VkSubpassDependency*        pDependencies;
	} VkRenderPassCreateInfo;

	typedef struct VkCommandPoolCreateInfo {
		VkStructureType             sType;
		const void*                 pNext;
		VkCommandPoolCreateFlags    flags;
		uint32_t                    queueFamilyIndex;
	} VkCommandPoolCreateInfo;

	typedef struct VkCommandBufferAllocateInfo {
		VkStructureType         sType;
		const void*             pNext;
		VkCommandPool           commandPool;
		VkCommandBufferLevel    level;
		uint32_t                commandBufferCount;
	} VkCommandBufferAllocateInfo;

	typedef struct VkCommandBufferInheritanceInfo {
		VkStructureType                  sType;
		const void*                      pNext;
		VkRenderPass                     renderPass;
		uint32_t                         subpass;
		VkFramebuffer                    framebuffer;
		VkBool32                         occlusionQueryEnable;
		VkQueryControlFlags              queryFlags;
		VkQueryPipelineStatisticFlags    pipelineStatistics;
	} VkCommandBufferInheritanceInfo;

	typedef struct VkCommandBufferBeginInfo {
		VkStructureType                          sType;
		const void*                              pNext;
		VkCommandBufferUsageFlags                flags;
		const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
	} VkCommandBufferBeginInfo;

	typedef struct VkBufferCopy {
		VkDeviceSize    srcOffset;
		VkDeviceSize    dstOffset;
		VkDeviceSize    size;
	} VkBufferCopy;

	typedef struct VkImageSubresourceLayers {
		VkImageAspectFlags    aspectMask;
		uint32_t              mipLevel;
		uint32_t              baseArrayLayer;
		uint32_t              layerCount;
	} VkImageSubresourceLayers;

	typedef struct VkImageCopy {
		VkImageSubresourceLayers    srcSubresource;
		VkOffset3D                  srcOffset;
		VkImageSubresourceLayers    dstSubresource;
		VkOffset3D                  dstOffset;
		VkExtent3D                  extent;
	} VkImageCopy;

	typedef struct VkImageBlit {
		VkImageSubresourceLayers    srcSubresource;
		VkOffset3D                  srcOffsets[2];
		VkImageSubresourceLayers    dstSubresource;
		VkOffset3D                  dstOffsets[2];
	} VkImageBlit;

	typedef struct VkBufferImageCopy {
		VkDeviceSize                bufferOffset;
		uint32_t                    bufferRowLength;
		uint32_t                    bufferImageHeight;
		VkImageSubresourceLayers    imageSubresource;
		VkOffset3D                  imageOffset;
		VkExtent3D                  imageExtent;
	} VkBufferImageCopy;

	typedef union VkClearColorValue {
		float       float32[4];
		int32_t     int32[4];
		uint32_t    uint32[4];
	} VkClearColorValue;

	typedef struct VkClearDepthStencilValue {
		float       depth;
		uint32_t    stencil;
	} VkClearDepthStencilValue;

	typedef union VkClearValue {
		VkClearColorValue           color;
		VkClearDepthStencilValue    depthStencil;
	} VkClearValue;

	typedef struct VkClearAttachment {
		VkImageAspectFlags    aspectMask;
		uint32_t              colorAttachment;
		VkClearValue          clearValue;
	} VkClearAttachment;

	typedef struct VkClearRect {
		VkRect2D    rect;
		uint32_t    baseArrayLayer;
		uint32_t    layerCount;
	} VkClearRect;

	typedef struct VkImageResolve {
		VkImageSubresourceLayers    srcSubresource;
		VkOffset3D                  srcOffset;
		VkImageSubresourceLayers    dstSubresource;
		VkOffset3D                  dstOffset;
		VkExtent3D                  extent;
	} VkImageResolve;

	typedef struct VkMemoryBarrier {
		VkStructureType    sType;
		const void*        pNext;
		VkAccessFlags      srcAccessMask;
		VkAccessFlags      dstAccessMask;
	} VkMemoryBarrier;

	typedef struct VkBufferMemoryBarrier {
		VkStructureType    sType;
		const void*        pNext;
		VkAccessFlags      srcAccessMask;
		VkAccessFlags      dstAccessMask;
		uint32_t           srcQueueFamilyIndex;
		uint32_t           dstQueueFamilyIndex;
		VkBuffer           buffer;
		VkDeviceSize       offset;
		VkDeviceSize       size;
	} VkBufferMemoryBarrier;

	typedef struct VkImageMemoryBarrier {
		VkStructureType            sType;
		const void*                pNext;
		VkAccessFlags              srcAccessMask;
		VkAccessFlags              dstAccessMask;
		VkImageLayout              oldLayout;
		VkImageLayout              newLayout;
		uint32_t                   srcQueueFamilyIndex;
		uint32_t                   dstQueueFamilyIndex;
		VkImage                    image;
		VkImageSubresourceRange    subresourceRange;
	} VkImageMemoryBarrier;

	typedef struct VkRenderPassBeginInfo {
		VkStructureType        sType;
		const void*            pNext;
		VkRenderPass           renderPass;
		VkFramebuffer          framebuffer;
		VkRect2D               renderArea;
		uint32_t               clearValueCount;
		const VkClearValue*    pClearValues;
	} VkRenderPassBeginInfo;

	typedef struct VkDispatchIndirectCommand {
		uint32_t    x;
		uint32_t    y;
		uint32_t    z;
	} VkDispatchIndirectCommand;

	typedef struct VkDrawIndexedIndirectCommand {
		uint32_t    indexCount;
		uint32_t    instanceCount;
		uint32_t    firstIndex;
		int32_t     vertexOffset;
		uint32_t    firstInstance;
	} VkDrawIndexedIndirectCommand;

	typedef struct VkDrawIndirectCommand {
		uint32_t    vertexCount;
		uint32_t    instanceCount;
		uint32_t    firstVertex;
		uint32_t    firstInstance;
	} VkDrawIndirectCommand;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance);
	typedef void (VKAPI_PTR *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices);
	typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures);
	typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties);
	typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties);
	typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties);
	typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties);
	typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName);
	typedef PFN_vkVoidFunction(VKAPI_PTR *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice);
	typedef void (VKAPI_PTR *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties);
	typedef void (VKAPI_PTR *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue);
	typedef VkResult(VKAPI_PTR *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence);
	typedef VkResult(VKAPI_PTR *PFN_vkQueueWaitIdle)(VkQueue queue);
	typedef VkResult(VKAPI_PTR *PFN_vkDeviceWaitIdle)(VkDevice device);
	typedef VkResult(VKAPI_PTR *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory);
	typedef void (VKAPI_PTR *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData);
	typedef void (VKAPI_PTR *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory);
	typedef VkResult(VKAPI_PTR *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
	typedef VkResult(VKAPI_PTR *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges);
	typedef void (VKAPI_PTR *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes);
	typedef VkResult(VKAPI_PTR *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset);
	typedef VkResult(VKAPI_PTR *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset);
	typedef void (VKAPI_PTR *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements);
	typedef void (VKAPI_PTR *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements);
	typedef void (VKAPI_PTR *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements);
	typedef void (VKAPI_PTR *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence);
	typedef void (VKAPI_PTR *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences);
	typedef VkResult(VKAPI_PTR *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence);
	typedef VkResult(VKAPI_PTR *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore);
	typedef void (VKAPI_PTR *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent);
	typedef void (VKAPI_PTR *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkGetEventStatus)(VkDevice device, VkEvent event);
	typedef VkResult(VKAPI_PTR *PFN_vkSetEvent)(VkDevice device, VkEvent event);
	typedef VkResult(VKAPI_PTR *PFN_vkResetEvent)(VkDevice device, VkEvent event);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool);
	typedef void (VKAPI_PTR *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer);
	typedef void (VKAPI_PTR *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView);
	typedef void (VKAPI_PTR *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage);
	typedef void (VKAPI_PTR *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator);
	typedef void (VKAPI_PTR *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView);
	typedef void (VKAPI_PTR *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule);
	typedef void (VKAPI_PTR *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache);
	typedef void (VKAPI_PTR *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData);
	typedef VkResult(VKAPI_PTR *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines);
	typedef void (VKAPI_PTR *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout);
	typedef void (VKAPI_PTR *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler);
	typedef void (VKAPI_PTR *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout);
	typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool);
	typedef void (VKAPI_PTR *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags);
	typedef VkResult(VKAPI_PTR *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets);
	typedef VkResult(VKAPI_PTR *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets);
	typedef void (VKAPI_PTR *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer);
	typedef void (VKAPI_PTR *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass);
	typedef void (VKAPI_PTR *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator);
	typedef void (VKAPI_PTR *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool);
	typedef void (VKAPI_PTR *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags);
	typedef VkResult(VKAPI_PTR *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers);
	typedef void (VKAPI_PTR *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
	typedef VkResult(VKAPI_PTR *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo);
	typedef VkResult(VKAPI_PTR *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer);
	typedef VkResult(VKAPI_PTR *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags);
	typedef void (VKAPI_PTR *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline);
	typedef void (VKAPI_PTR *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports);
	typedef void (VKAPI_PTR *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors);
	typedef void (VKAPI_PTR *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth);
	typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor);
	typedef void (VKAPI_PTR *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]);
	typedef void (VKAPI_PTR *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds);
	typedef void (VKAPI_PTR *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask);
	typedef void (VKAPI_PTR *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask);
	typedef void (VKAPI_PTR *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference);
	typedef void (VKAPI_PTR *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets);
	typedef void (VKAPI_PTR *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType);
	typedef void (VKAPI_PTR *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets);
	typedef void (VKAPI_PTR *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance);
	typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance);
	typedef void (VKAPI_PTR *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
	typedef void (VKAPI_PTR *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride);
	typedef void (VKAPI_PTR *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z);
	typedef void (VKAPI_PTR *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset);
	typedef void (VKAPI_PTR *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions);
	typedef void (VKAPI_PTR *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions);
	typedef void (VKAPI_PTR *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter);
	typedef void (VKAPI_PTR *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions);
	typedef void (VKAPI_PTR *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions);
	typedef void (VKAPI_PTR *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData);
	typedef void (VKAPI_PTR *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data);
	typedef void (VKAPI_PTR *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
	typedef void (VKAPI_PTR *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges);
	typedef void (VKAPI_PTR *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects);
	typedef void (VKAPI_PTR *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions);
	typedef void (VKAPI_PTR *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
	typedef void (VKAPI_PTR *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask);
	typedef void (VKAPI_PTR *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
	typedef void (VKAPI_PTR *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers);
	typedef void (VKAPI_PTR *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags);
	typedef void (VKAPI_PTR *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query);
	typedef void (VKAPI_PTR *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount);
	typedef void (VKAPI_PTR *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query);
	typedef void (VKAPI_PTR *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags);
	typedef void (VKAPI_PTR *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues);
	typedef void (VKAPI_PTR *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents);
	typedef void (VKAPI_PTR *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents);
	typedef void (VKAPI_PTR *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer);
	typedef void (VKAPI_PTR *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
		const VkInstanceCreateInfo*                 pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkInstance*                                 pInstance);

	VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
		VkInstance                                  instance,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
		VkInstance                                  instance,
		uint32_t*                                   pPhysicalDeviceCount,
		VkPhysicalDevice*                           pPhysicalDevices);

	VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
		VkPhysicalDevice                            physicalDevice,
		VkPhysicalDeviceFeatures*                   pFeatures);

	VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
		VkPhysicalDevice                            physicalDevice,
		VkFormat                                    format,
		VkFormatProperties*                         pFormatProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(
		VkPhysicalDevice                            physicalDevice,
		VkFormat                                    format,
		VkImageType                                 type,
		VkImageTiling                               tiling,
		VkImageUsageFlags                           usage,
		VkImageCreateFlags                          flags,
		VkImageFormatProperties*                    pImageFormatProperties);

	VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
		VkPhysicalDevice                            physicalDevice,
		VkPhysicalDeviceProperties*                 pProperties);

	VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
		VkPhysicalDevice                            physicalDevice,
		uint32_t*                                   pQueueFamilyPropertyCount,
		VkQueueFamilyProperties*                    pQueueFamilyProperties);

	VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
		VkPhysicalDevice                            physicalDevice,
		VkPhysicalDeviceMemoryProperties*           pMemoryProperties);

	VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetInstanceProcAddr(
		VkInstance                                  instance,
		const char*                                 pName);

	VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vkGetDeviceProcAddr(
		VkDevice                                    device,
		const char*                                 pName);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
		VkPhysicalDevice                            physicalDevice,
		const VkDeviceCreateInfo*                   pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkDevice*                                   pDevice);

	VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(
		VkDevice                                    device,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceExtensionProperties(
		const char*                                 pLayerName,
		uint32_t*                                   pPropertyCount,
		VkExtensionProperties*                      pProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
		VkPhysicalDevice                            physicalDevice,
		const char*                                 pLayerName,
		uint32_t*                                   pPropertyCount,
		VkExtensionProperties*                      pProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateInstanceLayerProperties(
		uint32_t*                                   pPropertyCount,
		VkLayerProperties*                          pProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
		VkPhysicalDevice                            physicalDevice,
		uint32_t*                                   pPropertyCount,
		VkLayerProperties*                          pProperties);

	VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(
		VkDevice                                    device,
		uint32_t                                    queueFamilyIndex,
		uint32_t                                    queueIndex,
		VkQueue*                                    pQueue);

	VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(
		VkQueue                                     queue,
		uint32_t                                    submitCount,
		const VkSubmitInfo*                         pSubmits,
		VkFence                                     fence);

	VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(
		VkQueue                                     queue);

	VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(
		VkDevice                                    device);

	VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(
		VkDevice                                    device,
		const VkMemoryAllocateInfo*                 pAllocateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkDeviceMemory*                             pMemory);

	VKAPI_ATTR void VKAPI_CALL vkFreeMemory(
		VkDevice                                    device,
		VkDeviceMemory                              memory,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(
		VkDevice                                    device,
		VkDeviceMemory                              memory,
		VkDeviceSize                                offset,
		VkDeviceSize                                size,
		VkMemoryMapFlags                            flags,
		void**                                      ppData);

	VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(
		VkDevice                                    device,
		VkDeviceMemory                              memory);

	VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(
		VkDevice                                    device,
		uint32_t                                    memoryRangeCount,
		const VkMappedMemoryRange*                  pMemoryRanges);

	VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(
		VkDevice                                    device,
		uint32_t                                    memoryRangeCount,
		const VkMappedMemoryRange*                  pMemoryRanges);

	VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(
		VkDevice                                    device,
		VkDeviceMemory                              memory,
		VkDeviceSize*                               pCommittedMemoryInBytes);

	VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(
		VkDevice                                    device,
		VkBuffer                                    buffer,
		VkDeviceMemory                              memory,
		VkDeviceSize                                memoryOffset);

	VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(
		VkDevice                                    device,
		VkImage                                     image,
		VkDeviceMemory                              memory,
		VkDeviceSize                                memoryOffset);

	VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(
		VkDevice                                    device,
		VkBuffer                                    buffer,
		VkMemoryRequirements*                       pMemoryRequirements);

	VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(
		VkDevice                                    device,
		VkImage                                     image,
		VkMemoryRequirements*                       pMemoryRequirements);

	VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
		VkDevice                                    device,
		VkImage                                     image,
		uint32_t*                                   pSparseMemoryRequirementCount,
		VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);

	VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(
		VkPhysicalDevice                            physicalDevice,
		VkFormat                                    format,
		VkImageType                                 type,
		VkSampleCountFlagBits                       samples,
		VkImageUsageFlags                           usage,
		VkImageTiling                               tiling,
		uint32_t*                                   pPropertyCount,
		VkSparseImageFormatProperties*              pProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(
		VkQueue                                     queue,
		uint32_t                                    bindInfoCount,
		const VkBindSparseInfo*                     pBindInfo,
		VkFence                                     fence);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(
		VkDevice                                    device,
		const VkFenceCreateInfo*                    pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkFence*                                    pFence);

	VKAPI_ATTR void VKAPI_CALL vkDestroyFence(
		VkDevice                                    device,
		VkFence                                     fence,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(
		VkDevice                                    device,
		uint32_t                                    fenceCount,
		const VkFence*                              pFences);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(
		VkDevice                                    device,
		VkFence                                     fence);

	VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(
		VkDevice                                    device,
		uint32_t                                    fenceCount,
		const VkFence*                              pFences,
		VkBool32                                    waitAll,
		uint64_t                                    timeout);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(
		VkDevice                                    device,
		const VkSemaphoreCreateInfo*                pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSemaphore*                                pSemaphore);

	VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(
		VkDevice                                    device,
		VkSemaphore                                 semaphore,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(
		VkDevice                                    device,
		const VkEventCreateInfo*                    pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkEvent*                                    pEvent);

	VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(
		VkDevice                                    device,
		VkEvent                                     event,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(
		VkDevice                                    device,
		VkEvent                                     event);

	VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(
		VkDevice                                    device,
		VkEvent                                     event);

	VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(
		VkDevice                                    device,
		VkEvent                                     event);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(
		VkDevice                                    device,
		const VkQueryPoolCreateInfo*                pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkQueryPool*                                pQueryPool);

	VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(
		VkDevice                                    device,
		VkQueryPool                                 queryPool,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(
		VkDevice                                    device,
		VkQueryPool                                 queryPool,
		uint32_t                                    firstQuery,
		uint32_t                                    queryCount,
		size_t                                      dataSize,
		void*                                       pData,
		VkDeviceSize                                stride,
		VkQueryResultFlags                          flags);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(
		VkDevice                                    device,
		const VkBufferCreateInfo*                   pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkBuffer*                                   pBuffer);

	VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(
		VkDevice                                    device,
		VkBuffer                                    buffer,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(
		VkDevice                                    device,
		const VkBufferViewCreateInfo*               pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkBufferView*                               pView);

	VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(
		VkDevice                                    device,
		VkBufferView                                bufferView,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(
		VkDevice                                    device,
		const VkImageCreateInfo*                    pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkImage*                                    pImage);

	VKAPI_ATTR void VKAPI_CALL vkDestroyImage(
		VkDevice                                    device,
		VkImage                                     image,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(
		VkDevice                                    device,
		VkImage                                     image,
		const VkImageSubresource*                   pSubresource,
		VkSubresourceLayout*                        pLayout);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(
		VkDevice                                    device,
		const VkImageViewCreateInfo*                pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkImageView*                                pView);

	VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(
		VkDevice                                    device,
		VkImageView                                 imageView,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(
		VkDevice                                    device,
		const VkShaderModuleCreateInfo*             pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkShaderModule*                             pShaderModule);

	VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(
		VkDevice                                    device,
		VkShaderModule                              shaderModule,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(
		VkDevice                                    device,
		const VkPipelineCacheCreateInfo*            pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkPipelineCache*                            pPipelineCache);

	VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(
		VkDevice                                    device,
		VkPipelineCache                             pipelineCache,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(
		VkDevice                                    device,
		VkPipelineCache                             pipelineCache,
		size_t*                                     pDataSize,
		void*                                       pData);

	VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(
		VkDevice                                    device,
		VkPipelineCache                             dstCache,
		uint32_t                                    srcCacheCount,
		const VkPipelineCache*                      pSrcCaches);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(
		VkDevice                                    device,
		VkPipelineCache                             pipelineCache,
		uint32_t                                    createInfoCount,
		const VkGraphicsPipelineCreateInfo*         pCreateInfos,
		const VkAllocationCallbacks*                pAllocator,
		VkPipeline*                                 pPipelines);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(
		VkDevice                                    device,
		VkPipelineCache                             pipelineCache,
		uint32_t                                    createInfoCount,
		const VkComputePipelineCreateInfo*          pCreateInfos,
		const VkAllocationCallbacks*                pAllocator,
		VkPipeline*                                 pPipelines);

	VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(
		VkDevice                                    device,
		VkPipeline                                  pipeline,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(
		VkDevice                                    device,
		const VkPipelineLayoutCreateInfo*           pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkPipelineLayout*                           pPipelineLayout);

	VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(
		VkDevice                                    device,
		VkPipelineLayout                            pipelineLayout,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(
		VkDevice                                    device,
		const VkSamplerCreateInfo*                  pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSampler*                                  pSampler);

	VKAPI_ATTR void VKAPI_CALL vkDestroySampler(
		VkDevice                                    device,
		VkSampler                                   sampler,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(
		VkDevice                                    device,
		const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkDescriptorSetLayout*                      pSetLayout);

	VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(
		VkDevice                                    device,
		VkDescriptorSetLayout                       descriptorSetLayout,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(
		VkDevice                                    device,
		const VkDescriptorPoolCreateInfo*           pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkDescriptorPool*                           pDescriptorPool);

	VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(
		VkDevice                                    device,
		VkDescriptorPool                            descriptorPool,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(
		VkDevice                                    device,
		VkDescriptorPool                            descriptorPool,
		VkDescriptorPoolResetFlags                  flags);

	VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(
		VkDevice                                    device,
		const VkDescriptorSetAllocateInfo*          pAllocateInfo,
		VkDescriptorSet*                            pDescriptorSets);

	VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(
		VkDevice                                    device,
		VkDescriptorPool                            descriptorPool,
		uint32_t                                    descriptorSetCount,
		const VkDescriptorSet*                      pDescriptorSets);

	VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(
		VkDevice                                    device,
		uint32_t                                    descriptorWriteCount,
		const VkWriteDescriptorSet*                 pDescriptorWrites,
		uint32_t                                    descriptorCopyCount,
		const VkCopyDescriptorSet*                  pDescriptorCopies);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(
		VkDevice                                    device,
		const VkFramebufferCreateInfo*              pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkFramebuffer*                              pFramebuffer);

	VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(
		VkDevice                                    device,
		VkFramebuffer                               framebuffer,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(
		VkDevice                                    device,
		const VkRenderPassCreateInfo*               pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkRenderPass*                               pRenderPass);

	VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(
		VkDevice                                    device,
		VkRenderPass                                renderPass,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(
		VkDevice                                    device,
		VkRenderPass                                renderPass,
		VkExtent2D*                                 pGranularity);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(
		VkDevice                                    device,
		const VkCommandPoolCreateInfo*              pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkCommandPool*                              pCommandPool);

	VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(
		VkDevice                                    device,
		VkCommandPool                               commandPool,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(
		VkDevice                                    device,
		VkCommandPool                               commandPool,
		VkCommandPoolResetFlags                     flags);

	VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
		VkDevice                                    device,
		const VkCommandBufferAllocateInfo*          pAllocateInfo,
		VkCommandBuffer*                            pCommandBuffers);

	VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
		VkDevice                                    device,
		VkCommandPool                               commandPool,
		uint32_t                                    commandBufferCount,
		const VkCommandBuffer*                      pCommandBuffers);

	VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(
		VkCommandBuffer                             commandBuffer,
		const VkCommandBufferBeginInfo*             pBeginInfo);

	VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(
		VkCommandBuffer                             commandBuffer);

	VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(
		VkCommandBuffer                             commandBuffer,
		VkCommandBufferResetFlags                   flags);

	VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(
		VkCommandBuffer                             commandBuffer,
		VkPipelineBindPoint                         pipelineBindPoint,
		VkPipeline                                  pipeline);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    firstViewport,
		uint32_t                                    viewportCount,
		const VkViewport*                           pViewports);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    firstScissor,
		uint32_t                                    scissorCount,
		const VkRect2D*                             pScissors);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(
		VkCommandBuffer                             commandBuffer,
		float                                       lineWidth);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(
		VkCommandBuffer                             commandBuffer,
		float                                       depthBiasConstantFactor,
		float                                       depthBiasClamp,
		float                                       depthBiasSlopeFactor);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(
		VkCommandBuffer                             commandBuffer,
		const float                                 blendConstants[4]);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(
		VkCommandBuffer                             commandBuffer,
		float                                       minDepthBounds,
		float                                       maxDepthBounds);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(
		VkCommandBuffer                             commandBuffer,
		VkStencilFaceFlags                          faceMask,
		uint32_t                                    compareMask);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(
		VkCommandBuffer                             commandBuffer,
		VkStencilFaceFlags                          faceMask,
		uint32_t                                    writeMask);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(
		VkCommandBuffer                             commandBuffer,
		VkStencilFaceFlags                          faceMask,
		uint32_t                                    reference);

	VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
		VkCommandBuffer                             commandBuffer,
		VkPipelineBindPoint                         pipelineBindPoint,
		VkPipelineLayout                            layout,
		uint32_t                                    firstSet,
		uint32_t                                    descriptorSetCount,
		const VkDescriptorSet*                      pDescriptorSets,
		uint32_t                                    dynamicOffsetCount,
		const uint32_t*                             pDynamicOffsets);

	VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    buffer,
		VkDeviceSize                                offset,
		VkIndexType                                 indexType);

	VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    firstBinding,
		uint32_t                                    bindingCount,
		const VkBuffer*                             pBuffers,
		const VkDeviceSize*                         pOffsets);

	VKAPI_ATTR void VKAPI_CALL vkCmdDraw(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    vertexCount,
		uint32_t                                    instanceCount,
		uint32_t                                    firstVertex,
		uint32_t                                    firstInstance);

	VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    indexCount,
		uint32_t                                    instanceCount,
		uint32_t                                    firstIndex,
		int32_t                                     vertexOffset,
		uint32_t                                    firstInstance);

	VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    buffer,
		VkDeviceSize                                offset,
		uint32_t                                    drawCount,
		uint32_t                                    stride);

	VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    buffer,
		VkDeviceSize                                offset,
		uint32_t                                    drawCount,
		uint32_t                                    stride);

	VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    x,
		uint32_t                                    y,
		uint32_t                                    z);

	VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    buffer,
		VkDeviceSize                                offset);

	VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    srcBuffer,
		VkBuffer                                    dstBuffer,
		uint32_t                                    regionCount,
		const VkBufferCopy*                         pRegions);

	VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(
		VkCommandBuffer                             commandBuffer,
		VkImage                                     srcImage,
		VkImageLayout                               srcImageLayout,
		VkImage                                     dstImage,
		VkImageLayout                               dstImageLayout,
		uint32_t                                    regionCount,
		const VkImageCopy*                          pRegions);

	VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(
		VkCommandBuffer                             commandBuffer,
		VkImage                                     srcImage,
		VkImageLayout                               srcImageLayout,
		VkImage                                     dstImage,
		VkImageLayout                               dstImageLayout,
		uint32_t                                    regionCount,
		const VkImageBlit*                          pRegions,
		VkFilter                                    filter);

	VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    srcBuffer,
		VkImage                                     dstImage,
		VkImageLayout                               dstImageLayout,
		uint32_t                                    regionCount,
		const VkBufferImageCopy*                    pRegions);

	VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(
		VkCommandBuffer                             commandBuffer,
		VkImage                                     srcImage,
		VkImageLayout                               srcImageLayout,
		VkBuffer                                    dstBuffer,
		uint32_t                                    regionCount,
		const VkBufferImageCopy*                    pRegions);

	VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    dstBuffer,
		VkDeviceSize                                dstOffset,
		VkDeviceSize                                dataSize,
		const uint32_t*                             pData);

	VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(
		VkCommandBuffer                             commandBuffer,
		VkBuffer                                    dstBuffer,
		VkDeviceSize                                dstOffset,
		VkDeviceSize                                size,
		uint32_t                                    data);

	VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(
		VkCommandBuffer                             commandBuffer,
		VkImage                                     image,
		VkImageLayout                               imageLayout,
		const VkClearColorValue*                    pColor,
		uint32_t                                    rangeCount,
		const VkImageSubresourceRange*              pRanges);

	VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(
		VkCommandBuffer                             commandBuffer,
		VkImage                                     image,
		VkImageLayout                               imageLayout,
		const VkClearDepthStencilValue*             pDepthStencil,
		uint32_t                                    rangeCount,
		const VkImageSubresourceRange*              pRanges);

	VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    attachmentCount,
		const VkClearAttachment*                    pAttachments,
		uint32_t                                    rectCount,
		const VkClearRect*                          pRects);

	VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(
		VkCommandBuffer                             commandBuffer,
		VkImage                                     srcImage,
		VkImageLayout                               srcImageLayout,
		VkImage                                     dstImage,
		VkImageLayout                               dstImageLayout,
		uint32_t                                    regionCount,
		const VkImageResolve*                       pRegions);

	VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(
		VkCommandBuffer                             commandBuffer,
		VkEvent                                     event,
		VkPipelineStageFlags                        stageMask);

	VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(
		VkCommandBuffer                             commandBuffer,
		VkEvent                                     event,
		VkPipelineStageFlags                        stageMask);

	VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    eventCount,
		const VkEvent*                              pEvents,
		VkPipelineStageFlags                        srcStageMask,
		VkPipelineStageFlags                        dstStageMask,
		uint32_t                                    memoryBarrierCount,
		const VkMemoryBarrier*                      pMemoryBarriers,
		uint32_t                                    bufferMemoryBarrierCount,
		const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
		uint32_t                                    imageMemoryBarrierCount,
		const VkImageMemoryBarrier*                 pImageMemoryBarriers);

	VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
		VkCommandBuffer                             commandBuffer,
		VkPipelineStageFlags                        srcStageMask,
		VkPipelineStageFlags                        dstStageMask,
		VkDependencyFlags                           dependencyFlags,
		uint32_t                                    memoryBarrierCount,
		const VkMemoryBarrier*                      pMemoryBarriers,
		uint32_t                                    bufferMemoryBarrierCount,
		const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
		uint32_t                                    imageMemoryBarrierCount,
		const VkImageMemoryBarrier*                 pImageMemoryBarriers);

	VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(
		VkCommandBuffer                             commandBuffer,
		VkQueryPool                                 queryPool,
		uint32_t                                    query,
		VkQueryControlFlags                         flags);

	VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(
		VkCommandBuffer                             commandBuffer,
		VkQueryPool                                 queryPool,
		uint32_t                                    query);

	VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(
		VkCommandBuffer                             commandBuffer,
		VkQueryPool                                 queryPool,
		uint32_t                                    firstQuery,
		uint32_t                                    queryCount);

	VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(
		VkCommandBuffer                             commandBuffer,
		VkPipelineStageFlagBits                     pipelineStage,
		VkQueryPool                                 queryPool,
		uint32_t                                    query);

	VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(
		VkCommandBuffer                             commandBuffer,
		VkQueryPool                                 queryPool,
		uint32_t                                    firstQuery,
		uint32_t                                    queryCount,
		VkBuffer                                    dstBuffer,
		VkDeviceSize                                dstOffset,
		VkDeviceSize                                stride,
		VkQueryResultFlags                          flags);

	VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(
		VkCommandBuffer                             commandBuffer,
		VkPipelineLayout                            layout,
		VkShaderStageFlags                          stageFlags,
		uint32_t                                    offset,
		uint32_t                                    size,
		const void*                                 pValues);

	VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(
		VkCommandBuffer                             commandBuffer,
		const VkRenderPassBeginInfo*                pRenderPassBegin,
		VkSubpassContents                           contents);

	VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(
		VkCommandBuffer                             commandBuffer,
		VkSubpassContents                           contents);

	VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(
		VkCommandBuffer                             commandBuffer);

	VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(
		VkCommandBuffer                             commandBuffer,
		uint32_t                                    commandBufferCount,
		const VkCommandBuffer*                      pCommandBuffers);
#endif

#define VK_KHR_surface 1
	VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSurfaceKHR)

#define VK_KHR_SURFACE_SPEC_VERSION       25
#define VK_KHR_SURFACE_EXTENSION_NAME     "VK_KHR_surface"


		typedef enum VkColorSpaceKHR {
		VK_COLORSPACE_SRGB_NONLINEAR_KHR = 0,
		VK_COLORSPACE_BEGIN_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
		VK_COLORSPACE_END_RANGE = VK_COLORSPACE_SRGB_NONLINEAR_KHR,
		VK_COLORSPACE_RANGE_SIZE = (VK_COLORSPACE_SRGB_NONLINEAR_KHR - VK_COLORSPACE_SRGB_NONLINEAR_KHR + 1),
		VK_COLORSPACE_MAX_ENUM = 0x7FFFFFFF
	} VkColorSpaceKHR;

	typedef enum VkPresentModeKHR {
		VK_PRESENT_MODE_IMMEDIATE_KHR = 0,
		VK_PRESENT_MODE_MAILBOX_KHR = 1,
		VK_PRESENT_MODE_FIFO_KHR = 2,
		VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3,
		VK_PRESENT_MODE_BEGIN_RANGE = VK_PRESENT_MODE_IMMEDIATE_KHR,
		VK_PRESENT_MODE_END_RANGE = VK_PRESENT_MODE_FIFO_RELAXED_KHR,
		VK_PRESENT_MODE_RANGE_SIZE = (VK_PRESENT_MODE_FIFO_RELAXED_KHR - VK_PRESENT_MODE_IMMEDIATE_KHR + 1),
		VK_PRESENT_MODE_MAX_ENUM = 0x7FFFFFFF
	} VkPresentModeKHR;


	typedef enum VkSurfaceTransformFlagBitsKHR {
		VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001,
		VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002,
		VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004,
		VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008,
		VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010,
		VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020,
		VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040,
		VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080,
		VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100,
	} VkSurfaceTransformFlagBitsKHR;
	typedef VkFlags VkSurfaceTransformFlagsKHR;

	typedef enum VkCompositeAlphaFlagBitsKHR {
		VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
		VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002,
		VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004,
		VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008,
	} VkCompositeAlphaFlagBitsKHR;
	typedef VkFlags VkCompositeAlphaFlagsKHR;

	typedef struct VkSurfaceCapabilitiesKHR {
		uint32_t                         minImageCount;
		uint32_t                         maxImageCount;
		VkExtent2D                       currentExtent;
		VkExtent2D                       minImageExtent;
		VkExtent2D                       maxImageExtent;
		uint32_t                         maxImageArrayLayers;
		VkSurfaceTransformFlagsKHR       supportedTransforms;
		VkSurfaceTransformFlagBitsKHR    currentTransform;
		VkCompositeAlphaFlagsKHR         supportedCompositeAlpha;
		VkImageUsageFlags                supportedUsageFlags;
	} VkSurfaceCapabilitiesKHR;

	typedef struct VkSurfaceFormatKHR {
		VkFormat           format;
		VkColorSpaceKHR    colorSpace;
	} VkSurfaceFormatKHR;


	typedef void (VKAPI_PTR *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported);
	typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities);
	typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats);
	typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR(
		VkInstance                                  instance,
		VkSurfaceKHR                                surface,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t                                    queueFamilyIndex,
		VkSurfaceKHR                                surface,
		VkBool32*                                   pSupported);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR(
		VkPhysicalDevice                            physicalDevice,
		VkSurfaceKHR                                surface,
		VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR(
		VkPhysicalDevice                            physicalDevice,
		VkSurfaceKHR                                surface,
		uint32_t*                                   pSurfaceFormatCount,
		VkSurfaceFormatKHR*                         pSurfaceFormats);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR(
		VkPhysicalDevice                            physicalDevice,
		VkSurfaceKHR                                surface,
		uint32_t*                                   pPresentModeCount,
		VkPresentModeKHR*                           pPresentModes);
#endif

#define VK_KHR_swapchain 1
	VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR)

#define VK_KHR_SWAPCHAIN_SPEC_VERSION     67
#define VK_KHR_SWAPCHAIN_EXTENSION_NAME   "VK_KHR_swapchain"

		typedef VkFlags VkSwapchainCreateFlagsKHR;

	typedef struct VkSwapchainCreateInfoKHR {
		VkStructureType                  sType;
		const void*                      pNext;
		VkSwapchainCreateFlagsKHR        flags;
		VkSurfaceKHR                     surface;
		uint32_t                         minImageCount;
		VkFormat                         imageFormat;
		VkColorSpaceKHR                  imageColorSpace;
		VkExtent2D                       imageExtent;
		uint32_t                         imageArrayLayers;
		VkImageUsageFlags                imageUsage;
		VkSharingMode                    imageSharingMode;
		uint32_t                         queueFamilyIndexCount;
		const uint32_t*                  pQueueFamilyIndices;
		VkSurfaceTransformFlagBitsKHR    preTransform;
		VkCompositeAlphaFlagBitsKHR      compositeAlpha;
		VkPresentModeKHR                 presentMode;
		VkBool32                         clipped;
		VkSwapchainKHR                   oldSwapchain;
	} VkSwapchainCreateInfoKHR;

	typedef struct VkPresentInfoKHR {
		VkStructureType          sType;
		const void*              pNext;
		uint32_t                 waitSemaphoreCount;
		const VkSemaphore*       pWaitSemaphores;
		uint32_t                 swapchainCount;
		const VkSwapchainKHR*    pSwapchains;
		const uint32_t*          pImageIndices;
		VkResult*                pResults;
	} VkPresentInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain);
	typedef void (VKAPI_PTR *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator);
	typedef VkResult(VKAPI_PTR *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages);
	typedef VkResult(VKAPI_PTR *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex);
	typedef VkResult(VKAPI_PTR *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateSwapchainKHR(
		VkDevice                                    device,
		const VkSwapchainCreateInfoKHR*             pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSwapchainKHR*                             pSwapchain);

	VKAPI_ATTR void VKAPI_CALL vkDestroySwapchainKHR(
		VkDevice                                    device,
		VkSwapchainKHR                              swapchain,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainImagesKHR(
		VkDevice                                    device,
		VkSwapchainKHR                              swapchain,
		uint32_t*                                   pSwapchainImageCount,
		VkImage*                                    pSwapchainImages);

	VKAPI_ATTR VkResult VKAPI_CALL vkAcquireNextImageKHR(
		VkDevice                                    device,
		VkSwapchainKHR                              swapchain,
		uint64_t                                    timeout,
		VkSemaphore                                 semaphore,
		VkFence                                     fence,
		uint32_t*                                   pImageIndex);

	VKAPI_ATTR VkResult VKAPI_CALL vkQueuePresentKHR(
		VkQueue                                     queue,
		const VkPresentInfoKHR*                     pPresentInfo);
#endif

#define VK_KHR_display 1
	VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayKHR)
		VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDisplayModeKHR)

#define VK_KHR_DISPLAY_SPEC_VERSION       21
#define VK_KHR_DISPLAY_EXTENSION_NAME     "VK_KHR_display"


		typedef enum VkDisplayPlaneAlphaFlagBitsKHR {
		VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001,
		VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002,
		VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004,
		VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008,
	} VkDisplayPlaneAlphaFlagBitsKHR;
	typedef VkFlags VkDisplayModeCreateFlagsKHR;
	typedef VkFlags VkDisplayPlaneAlphaFlagsKHR;
	typedef VkFlags VkDisplaySurfaceCreateFlagsKHR;

	typedef struct VkDisplayPropertiesKHR {
		VkDisplayKHR                  display;
		const char*                   displayName;
		VkExtent2D                    physicalDimensions;
		VkExtent2D                    physicalResolution;
		VkSurfaceTransformFlagsKHR    supportedTransforms;
		VkBool32                      planeReorderPossible;
		VkBool32                      persistentContent;
	} VkDisplayPropertiesKHR;

	typedef struct VkDisplayModeParametersKHR {
		VkExtent2D    visibleRegion;
		uint32_t      refreshRate;
	} VkDisplayModeParametersKHR;

	typedef struct VkDisplayModePropertiesKHR {
		VkDisplayModeKHR              displayMode;
		VkDisplayModeParametersKHR    parameters;
	} VkDisplayModePropertiesKHR;

	typedef struct VkDisplayModeCreateInfoKHR {
		VkStructureType                sType;
		const void*                    pNext;
		VkDisplayModeCreateFlagsKHR    flags;
		VkDisplayModeParametersKHR     parameters;
	} VkDisplayModeCreateInfoKHR;

	typedef struct VkDisplayPlaneCapabilitiesKHR {
		VkDisplayPlaneAlphaFlagsKHR    supportedAlpha;
		VkOffset2D                     minSrcPosition;
		VkOffset2D                     maxSrcPosition;
		VkExtent2D                     minSrcExtent;
		VkExtent2D                     maxSrcExtent;
		VkOffset2D                     minDstPosition;
		VkOffset2D                     maxDstPosition;
		VkExtent2D                     minDstExtent;
		VkExtent2D                     maxDstExtent;
	} VkDisplayPlaneCapabilitiesKHR;

	typedef struct VkDisplayPlanePropertiesKHR {
		VkDisplayKHR    currentDisplay;
		uint32_t        currentStackIndex;
	} VkDisplayPlanePropertiesKHR;

	typedef struct VkDisplaySurfaceCreateInfoKHR {
		VkStructureType                   sType;
		const void*                       pNext;
		VkDisplaySurfaceCreateFlagsKHR    flags;
		VkDisplayModeKHR                  displayMode;
		uint32_t                          planeIndex;
		uint32_t                          planeStackIndex;
		VkSurfaceTransformFlagBitsKHR     transform;
		float                             globalAlpha;
		VkDisplayPlaneAlphaFlagBitsKHR    alphaMode;
		VkExtent2D                        imageExtent;
	} VkDisplaySurfaceCreateInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays);
	typedef VkResult(VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode);
	typedef VkResult(VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities);
	typedef VkResult(VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPropertiesKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t*                                   pPropertyCount,
		VkDisplayPropertiesKHR*                     pProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceDisplayPlanePropertiesKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t*                                   pPropertyCount,
		VkDisplayPlanePropertiesKHR*                pProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneSupportedDisplaysKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t                                    planeIndex,
		uint32_t*                                   pDisplayCount,
		VkDisplayKHR*                               pDisplays);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayModePropertiesKHR(
		VkPhysicalDevice                            physicalDevice,
		VkDisplayKHR                                display,
		uint32_t*                                   pPropertyCount,
		VkDisplayModePropertiesKHR*                 pProperties);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayModeKHR(
		VkPhysicalDevice                            physicalDevice,
		VkDisplayKHR                                display,
		const VkDisplayModeCreateInfoKHR*           pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkDisplayModeKHR*                           pMode);

	VKAPI_ATTR VkResult VKAPI_CALL vkGetDisplayPlaneCapabilitiesKHR(
		VkPhysicalDevice                            physicalDevice,
		VkDisplayModeKHR                            mode,
		uint32_t                                    planeIndex,
		VkDisplayPlaneCapabilitiesKHR*              pCapabilities);

	VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR(
		VkInstance                                  instance,
		const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSurfaceKHR*                               pSurface);
#endif

#define VK_KHR_display_swapchain 1
#define VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION 9
#define VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME "VK_KHR_display_swapchain"

	typedef struct VkDisplayPresentInfoKHR {
		VkStructureType    sType;
		const void*        pNext;
		VkRect2D           srcRect;
		VkRect2D           dstRect;
		VkBool32           persistent;
	} VkDisplayPresentInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateSharedSwapchainsKHR(
		VkDevice                                    device,
		uint32_t                                    swapchainCount,
		const VkSwapchainCreateInfoKHR*             pCreateInfos,
		const VkAllocationCallbacks*                pAllocator,
		VkSwapchainKHR*                             pSwapchains);
#endif

#ifdef VK_USE_PLATFORM_XLIB_KHR
#define VK_KHR_xlib_surface 1
#include <X11/Xlib.h>

#define VK_KHR_XLIB_SURFACE_SPEC_VERSION  6
#define VK_KHR_XLIB_SURFACE_EXTENSION_NAME "VK_KHR_xlib_surface"

	typedef VkFlags VkXlibSurfaceCreateFlagsKHR;

	typedef struct VkXlibSurfaceCreateInfoKHR {
		VkStructureType                sType;
		const void*                    pNext;
		VkXlibSurfaceCreateFlagsKHR    flags;
		Display*                       dpy;
		Window                         window;
	} VkXlibSurfaceCreateInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateXlibSurfaceKHR)(VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
	typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR(
		VkInstance                                  instance,
		const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSurfaceKHR*                               pSurface);

	VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXlibPresentationSupportKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t                                    queueFamilyIndex,
		Display*                                    dpy,
		VisualID                                    visualID);
#endif
#endif /* VK_USE_PLATFORM_XLIB_KHR */

#ifdef VK_USE_PLATFORM_XCB_KHR
#define VK_KHR_xcb_surface 1
#include <xcb/xcb.h>

#define VK_KHR_XCB_SURFACE_SPEC_VERSION   6
#define VK_KHR_XCB_SURFACE_EXTENSION_NAME "VK_KHR_xcb_surface"

	typedef VkFlags VkXcbSurfaceCreateFlagsKHR;

	typedef struct VkXcbSurfaceCreateInfoKHR {
		VkStructureType               sType;
		const void*                   pNext;
		VkXcbSurfaceCreateFlagsKHR    flags;
		xcb_connection_t*             connection;
		xcb_window_t                  window;
	} VkXcbSurfaceCreateInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateXcbSurfaceKHR)(VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
	typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR(
		VkInstance                                  instance,
		const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSurfaceKHR*                               pSurface);

	VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceXcbPresentationSupportKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t                                    queueFamilyIndex,
		xcb_connection_t*                           connection,
		xcb_visualid_t                              visual_id);
#endif
#endif /* VK_USE_PLATFORM_XCB_KHR */

#ifdef VK_USE_PLATFORM_WAYLAND_KHR
#define VK_KHR_wayland_surface 1
#include <wayland-client.h>

#define VK_KHR_WAYLAND_SURFACE_SPEC_VERSION 5
#define VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME "VK_KHR_wayland_surface"

	typedef VkFlags VkWaylandSurfaceCreateFlagsKHR;

	typedef struct VkWaylandSurfaceCreateInfoKHR {
		VkStructureType                   sType;
		const void*                       pNext;
		VkWaylandSurfaceCreateFlagsKHR    flags;
		struct wl_display*                display;
		struct wl_surface*                surface;
	} VkWaylandSurfaceCreateInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateWaylandSurfaceKHR)(VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
	typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR(
		VkInstance                                  instance,
		const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSurfaceKHR*                               pSurface);

	VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWaylandPresentationSupportKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t                                    queueFamilyIndex,
		struct wl_display*                          display);
#endif
#endif /* VK_USE_PLATFORM_WAYLAND_KHR */

#ifdef VK_USE_PLATFORM_MIR_KHR
#define VK_KHR_mir_surface 1
#include <mir_toolkit/client_types.h>

#define VK_KHR_MIR_SURFACE_SPEC_VERSION   4
#define VK_KHR_MIR_SURFACE_EXTENSION_NAME "VK_KHR_mir_surface"

	typedef VkFlags VkMirSurfaceCreateFlagsKHR;

	typedef struct VkMirSurfaceCreateInfoKHR {
		VkStructureType               sType;
		const void*                   pNext;
		VkMirSurfaceCreateFlagsKHR    flags;
		MirConnection*                connection;
		MirSurface*                   mirSurface;
	} VkMirSurfaceCreateInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateMirSurfaceKHR)(VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
	typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceMirPresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, MirConnection* connection);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateMirSurfaceKHR(
		VkInstance                                  instance,
		const VkMirSurfaceCreateInfoKHR*            pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSurfaceKHR*                               pSurface);

	VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceMirPresentationSupportKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t                                    queueFamilyIndex,
		MirConnection*                              connection);
#endif
#endif /* VK_USE_PLATFORM_MIR_KHR */

#ifdef VK_USE_PLATFORM_ANDROID_KHR
#define VK_KHR_android_surface 1
#include <android/native_window.h>

#define VK_KHR_ANDROID_SURFACE_SPEC_VERSION 6
#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"

	typedef VkFlags VkAndroidSurfaceCreateFlagsKHR;

	typedef struct VkAndroidSurfaceCreateInfoKHR {
		VkStructureType                   sType;
		const void*                       pNext;
		VkAndroidSurfaceCreateFlagsKHR    flags;
		ANativeWindow*                    window;
	} VkAndroidSurfaceCreateInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateAndroidSurfaceKHR)(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR(
		VkInstance                                  instance,
		const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSurfaceKHR*                               pSurface);
#endif
#endif /* VK_USE_PLATFORM_ANDROID_KHR */

#ifdef VK_USE_PLATFORM_WIN32_KHR
#define VK_KHR_win32_surface 1
#include <windows.h>

#define VK_KHR_WIN32_SURFACE_SPEC_VERSION 5
#define VK_KHR_WIN32_SURFACE_EXTENSION_NAME "VK_KHR_win32_surface"

	typedef VkFlags VkWin32SurfaceCreateFlagsKHR;

	typedef struct VkWin32SurfaceCreateInfoKHR {
		VkStructureType                 sType;
		const void*                     pNext;
		VkWin32SurfaceCreateFlagsKHR    flags;
		HINSTANCE                       hinstance;
		HWND                            hwnd;
	} VkWin32SurfaceCreateInfoKHR;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateWin32SurfaceKHR)(VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface);
	typedef VkBool32(VKAPI_PTR *PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR(
		VkInstance                                  instance,
		const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkSurfaceKHR*                               pSurface);

	VKAPI_ATTR VkBool32 VKAPI_CALL vkGetPhysicalDeviceWin32PresentationSupportKHR(
		VkPhysicalDevice                            physicalDevice,
		uint32_t                                    queueFamilyIndex);
#endif
#endif /* VK_USE_PLATFORM_WIN32_KHR */

#define VK_EXT_debug_report 1
	VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkDebugReportCallbackEXT)

#define VK_EXT_DEBUG_REPORT_SPEC_VERSION  1
#define VK_EXT_DEBUG_REPORT_EXTENSION_NAME "VK_EXT_debug_report"


		typedef enum VkDebugReportObjectTypeEXT {
		VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0,
		VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1,
		VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2,
		VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3,
		VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4,
		VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5,
		VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6,
		VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7,
		VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8,
		VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9,
		VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10,
		VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11,
		VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12,
		VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13,
		VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14,
		VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15,
		VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16,
		VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17,
		VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18,
		VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19,
		VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20,
		VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21,
		VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22,
		VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23,
		VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24,
		VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25,
		VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26,
		VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27,
		VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = 28,
	} VkDebugReportObjectTypeEXT;

	typedef enum VkDebugReportErrorEXT {
		VK_DEBUG_REPORT_ERROR_NONE_EXT = 0,
		VK_DEBUG_REPORT_ERROR_CALLBACK_REF_EXT = 1,
	} VkDebugReportErrorEXT;


	typedef enum VkDebugReportFlagBitsEXT {
		VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001,
		VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002,
		VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004,
		VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008,
		VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010,
	} VkDebugReportFlagBitsEXT;
	typedef VkFlags VkDebugReportFlagsEXT;

	typedef VkBool32(VKAPI_PTR *PFN_vkDebugReportCallbackEXT)(
		VkDebugReportFlagsEXT                       flags,
		VkDebugReportObjectTypeEXT                  objectType,
		uint64_t                                    object,
		size_t                                      location,
		int32_t                                     messageCode,
		const char*                                 pLayerPrefix,
		const char*                                 pMessage,
		void*                                       pUserData);


	typedef struct VkDebugReportCallbackCreateInfoEXT {
		VkStructureType                 sType;
		const void*                     pNext;
		VkDebugReportFlagsEXT           flags;
		PFN_vkDebugReportCallbackEXT    pfnCallback;
		void*                           pUserData;
	} VkDebugReportCallbackCreateInfoEXT;


	typedef VkResult(VKAPI_PTR *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);
	typedef void (VKAPI_PTR *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator);
	typedef void (VKAPI_PTR *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage);

#ifndef VK_NO_PROTOTYPES
	VKAPI_ATTR VkResult VKAPI_CALL vkCreateDebugReportCallbackEXT(
		VkInstance                                  instance,
		const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
		const VkAllocationCallbacks*                pAllocator,
		VkDebugReportCallbackEXT*                   pCallback);

	VKAPI_ATTR void VKAPI_CALL vkDestroyDebugReportCallbackEXT(
		VkInstance                                  instance,
		VkDebugReportCallbackEXT                    callback,
		const VkAllocationCallbacks*                pAllocator);

	VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT(
		VkInstance                                  instance,
		VkDebugReportFlagsEXT                       flags,
		VkDebugReportObjectTypeEXT                  objectType,
		uint64_t                                    object,
		size_t                                      location,
		int32_t                                     messageCode,
		const char*                                 pLayerPrefix,
		const char*                                 pMessage);
#endif

#ifdef __cplusplus
}
#endif

#endif
